@AllArgsConstructor
private static final class ModuleDelta {
Collection<ModuleReference> allModuleReferences;
- Map<String, String> newModuleNameToContentMap;
+ Map<String, String> newYangResourceContentPerName;
}
/**
if (sourceModuleSetTag.isEmpty() && targetModuleSetTag.isEmpty()) {
final ModuleDelta moduleDelta = getModuleDelta(yangModelCmHandle, targetModuleSetTag);
cpsModuleService.upgradeSchemaSetFromModules(NFP_OPERATIONAL_DATASTORE_DATASPACE_NAME,
- schemaSetName, moduleDelta.newModuleNameToContentMap, moduleDelta.allModuleReferences);
+ schemaSetName, moduleDelta.newYangResourceContentPerName, moduleDelta.allModuleReferences);
} else {
syncAndCreateSchemaSet(yangModelCmHandle, schemaSetName, targetModuleSetTag);
cpsAnchorService.updateAnchorSchemaSet(NFP_OPERATIONAL_DATASTORE_DATASPACE_NAME, cmHandleId, schemaSetName);
cpsModuleService.createSchemaSetFromModules(
NFP_OPERATIONAL_DATASTORE_DATASPACE_NAME,
schemaSetName,
- moduleDelta.newModuleNameToContentMap,
+ moduleDelta.newYangResourceContentPerName,
moduleDelta.allModuleReferences
);
log.info("Successfully created Schema Set {} for CM Handle {}", schemaSetName,
dmiModelOperations.getModuleReferences(yangModelCmHandle, targetModuleSetTag);
final Collection<ModuleReference> newModuleReferences =
cpsModuleService.identifyNewModuleReferences(allModuleReferences);
- final Map<String, String> newYangResources = dmiModelOperations.getNewYangResourcesFromDmi(yangModelCmHandle,
- targetModuleSetTag, newModuleReferences);
+ final Map<String, String> newYangResourceContentPerName =
+ dmiModelOperations.getNewYangResourcesFromDmi(yangModelCmHandle, targetModuleSetTag, newModuleReferences);
log.debug("Module delta calculated for CM handle ID: {}. All references: {}. New modules: {}",
- yangModelCmHandle.getId(), allModuleReferences, newYangResources.keySet());
- return new ModuleDelta(allModuleReferences, newYangResources);
+ yangModelCmHandle.getId(), allModuleReferences, newYangResourceContentPerName.keySet());
+ return new ModuleDelta(allModuleReferences, newYangResourceContentPerName);
}
private void setCmHandleModuleSetTag(final YangModelCmHandle yangModelCmHandle, final String newModuleSetTag) {
============LICENSE_START=======================================================\r
Copyright (C) 2020-2021 Pantheon.tech\r
Modifications Copyright (C) 2020-2021 Bell Canada\r
- Modifications Copyright (C) 2020-2024 Nordix Foundation\r
+ Modifications Copyright (C) 2020-2025 Nordix Foundation\r
================================================================================\r
Licensed under the Apache License, Version 2.0 (the "License");\r
you may not use this file except in compliance with the License.\r
<artifactId>cps-ri</artifactId>\r
\r
<properties>\r
- <minimum-coverage>0.29</minimum-coverage>\r
+ <minimum-coverage>0.31</minimum-coverage>\r
<!-- Additional coverage is provided by integration-test module -->\r
</properties>\r
\r
/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2020-2024 Nordix Foundation.
+ * Copyright (C) 2020-2025 Nordix Foundation.
* Modifications Copyright (C) 2020-2022 Bell Canada.
* Modifications Copyright (C) 2021 Pantheon.tech
* Modifications Copyright (C) 2022 TechMahindra Ltd.
@Override
public void createAnchor(final String dataspaceName, final String schemaSetName, final String anchorName) {
- final var dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
- final var schemaSetEntity =
- schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName);
- final var anchorEntity = AnchorEntity.builder()
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final SchemaSetEntity schemaSetEntity = schemaSetRepository
+ .getByDataspaceAndName(dataspaceEntity, schemaSetName);
+ final AnchorEntity anchorEntity = AnchorEntity.builder()
.name(anchorName)
.dataspace(dataspaceEntity)
.schemaSet(schemaSetEntity)
@Override
public Collection<Anchor> getAnchors(final String dataspaceName) {
- final var dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
final Collection<AnchorEntity> anchorEntities = anchorRepository.findAllByDataspace(dataspaceEntity);
return anchorEntities.stream().map(CpsAdminPersistenceServiceImpl::toAnchor).collect(Collectors.toSet());
}
@Transactional
@Override
public void deleteAnchor(final String dataspaceName, final String anchorName) {
- final var anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+ final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
anchorRepository.delete(anchorEntity);
}
@Transactional
@Override
public void deleteAnchors(final String dataspaceName, final Collection<String> anchorNames) {
- final var dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
anchorRepository.deleteAllByDataspaceAndNameIn(dataspaceEntity, anchorNames);
}
}
private AnchorEntity getAnchorEntity(final String dataspaceName, final String anchorName) {
- final var dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
return anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@Override
public Collection<ModuleReference> getYangResourceModuleReferences(final String dataspaceName) {
- final Set<YangResourceModuleReference> yangResourceModuleReferenceList =
+ final Collection<YangResourceModuleReference> yangResourceModuleReferences =
yangResourceRepository.findAllModuleReferencesByDataspace(dataspaceName);
- return yangResourceModuleReferenceList.stream().map(CpsModulePersistenceServiceImpl::toModuleReference)
- .collect(Collectors.toList());
+ return yangResourceModuleReferences.stream().map(CpsModulePersistenceServiceImpl::toModuleReference).toList();
}
@Override
@Override
@Transactional
- public void storeSchemaSet(final String dataspaceName, final String schemaSetName,
- final Map<String, String> moduleReferenceNameToContentMap) {
- final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
- final Set<YangResourceEntity> yangResourceEntities = synchronizeYangResources(moduleReferenceNameToContentMap);
- final SchemaSetEntity schemaSetEntity = new SchemaSetEntity();
- schemaSetEntity.setName(schemaSetName);
- schemaSetEntity.setDataspace(dataspaceEntity);
- schemaSetEntity.setYangResources(yangResourceEntities);
- try {
- schemaSetRepository.save(schemaSetEntity);
- } catch (final DataIntegrityViolationException e) {
- throw AlreadyDefinedException.forSchemaSet(schemaSetName, dataspaceName, e);
- }
+ @Timed(value = "cps.module.persistence.schemaset.create",
+ description = "Time taken to store a schemaset (list of module references)")
+ public void createSchemaSet(final String dataspaceName, final String schemaSetName,
+ final Map<String, String> yangResourceContentPerName) {
+ final Set<YangResourceEntity> yangResourceEntities = synchronizeYangResources(yangResourceContentPerName);
+ createAndSaveSchemaSetEntity(dataspaceName, schemaSetName, yangResourceEntities);
+ }
+
+ @Override
+ @Transactional
+ @Timed(value = "cps.module.persistence.schemaset.createFromNewAndExistingModules",
+ description = "Time taken to store a schemaset (from new and existing)")
+ public void createSchemaSetFromNewAndExistingModules(final String dataspaceName, final String schemaSetName,
+ final Map<String, String> newYangResourceContentPerName,
+ final Collection<ModuleReference> allModuleReferences) {
+ synchronizeYangResources(newYangResourceContentPerName);
+ final Set<YangResourceEntity> allYangResourceEntities = getYangResourceEntities(allModuleReferences);
+ createAndSaveSchemaSetEntity(dataspaceName, schemaSetName, allYangResourceEntities);
}
@Override
.map(CpsModulePersistenceServiceImpl::toSchemaSet).collect(Collectors.toList());
}
- @Override
- @Transactional
- @Timed(value = "cps.module.persistence.schemaset.store",
- description = "Time taken to store a schemaset (list of module references)")
- public void storeSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
- final Map<String, String> newModuleNameToContentMap,
- final Collection<ModuleReference> allModuleReferences) {
- storeSchemaSet(dataspaceName, schemaSetName, newModuleNameToContentMap);
- final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
- final SchemaSetEntity schemaSetEntity =
- schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName);
- final List<Integer> allYangResourceIds =
- yangResourceRepository.getResourceIdsByModuleReferences(allModuleReferences);
- yangResourceRepository.insertSchemaSetIdYangResourceId(schemaSetEntity.getId(), allYangResourceIds);
- }
-
@Override
@Transactional
public void deleteSchemaSet(final String dataspaceName, final String schemaSetName) {
@Override
@Transactional
- public void updateSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
- final Map<String, String> newModuleNameToContentMap,
- final Collection<ModuleReference> allModuleReferences) {
+ public void updateSchemaSetFromNewAndExistingModules(final String dataspaceName, final String schemaSetName,
+ final Map<String, String> newYangResourcesPerName,
+ final Collection<ModuleReference> allModuleReferences) {
final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
final SchemaSetEntity schemaSetEntity =
schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName);
- storeAndLinkNewModules(newModuleNameToContentMap, schemaSetEntity);
- updateAllModuleReferences(allModuleReferences, schemaSetEntity.getId());
+ synchronizeYangResources(newYangResourcesPerName);
+ final Set<YangResourceEntity> allYangResourceEntities = getYangResourceEntities(allModuleReferences);
+ schemaSetEntity.setYangResources(allYangResourceEntities);
+ schemaSetRepository.save(schemaSetEntity);
}
@Override
return moduleReferenceRepository.identifyNewModuleReferences(moduleReferencesToCheck);
}
- private Set<YangResourceEntity> synchronizeYangResources(
- final Map<String, String> moduleReferenceNameToContentMap) {
- final Map<String, YangResourceEntity> checksumToEntityMap = moduleReferenceNameToContentMap.entrySet().stream()
+ private Set<YangResourceEntity> synchronizeYangResources(final Map<String, String> yangResourceContentPerName) {
+ final Map<String, YangResourceEntity> yangResourceEntitiesPerChecksum =
+ getYangResourceEntityPerChecksum(yangResourceContentPerName);
+
+ final List<YangResourceEntity> existingYangResourceEntities =
+ yangResourceRepository.findAllByChecksumIn(yangResourceEntitiesPerChecksum.keySet());
+
+ existingYangResourceEntities.forEach(exist -> yangResourceEntitiesPerChecksum.remove(exist.getChecksum()));
+ final Collection<YangResourceEntity> newYangResourceEntities = yangResourceEntitiesPerChecksum.values();
+
+ if (!newYangResourceEntities.isEmpty()) {
+ try {
+ yangResourceRepository.saveAll(newYangResourceEntities);
+ } catch (final DataIntegrityViolationException dataIntegrityViolationException) {
+ convertExceptionIfNeeded(dataIntegrityViolationException, newYangResourceEntities);
+ }
+ }
+
+ // return ALL yang resourceEntities
+ return ImmutableSet.<YangResourceEntity>builder()
+ .addAll(existingYangResourceEntities)
+ .addAll(newYangResourceEntities)
+ .build();
+ }
+
+ private static Map<String, YangResourceEntity> getYangResourceEntityPerChecksum(
+ final Map<String, String> yangResourceContentPerName) {
+ final Map<String, YangResourceEntity> yangResourceEntityPerChecksum =
+ yangResourceContentPerName.entrySet().stream()
.map(entry -> {
final String checksum = DigestUtils.sha256Hex(entry.getValue().getBytes(StandardCharsets.UTF_8));
final Map<String, String> moduleNameAndRevisionMap = createModuleNameAndRevisionMap(entry.getKey(),
YangResourceEntity::getChecksum,
entity -> entity
));
+ return yangResourceEntityPerChecksum;
+ }
- final List<YangResourceEntity> existingYangResourceEntities =
- yangResourceRepository.findAllByChecksumIn(checksumToEntityMap.keySet());
- existingYangResourceEntities.forEach(yangFile -> checksumToEntityMap.remove(yangFile.getChecksum()));
-
- final Collection<YangResourceEntity> newYangResourceEntities = checksumToEntityMap.values();
- if (!newYangResourceEntities.isEmpty()) {
- try {
- yangResourceRepository.saveAll(newYangResourceEntities);
- } catch (final DataIntegrityViolationException dataIntegrityViolationException) {
- // Throw a CPS duplicated Yang resource exception if the cause of the error is a yang checksum
- // database constraint violation. If it is not, then throw the original exception
- final Optional<DuplicatedYangResourceException> convertedException =
- convertToDuplicatedYangResourceException(
- dataIntegrityViolationException, newYangResourceEntities);
- throw convertedException.isPresent() ? convertedException.get() : dataIntegrityViolationException;
- }
+ private void createAndSaveSchemaSetEntity(final String dataspaceName,
+ final String schemaSetName,
+ final Set<YangResourceEntity> yangResourceEntities) {
+ final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+ final SchemaSetEntity schemaSetEntity = new SchemaSetEntity();
+ schemaSetEntity.setName(schemaSetName);
+ schemaSetEntity.setDataspace(dataspaceEntity);
+ schemaSetEntity.setYangResources(yangResourceEntities);
+ try {
+ schemaSetRepository.save(schemaSetEntity);
+ } catch (final DataIntegrityViolationException e) {
+ throw AlreadyDefinedException.forSchemaSet(schemaSetName, dataspaceName, e);
}
-
- return ImmutableSet.<YangResourceEntity>builder()
- .addAll(existingYangResourceEntities)
- .addAll(newYangResourceEntities)
- .build();
}
private static Map<String, String> createModuleNameAndRevisionMap(final String sourceName, final String source) {
return RevisionSourceIdentifier.create(sourceName);
}
+ private void convertExceptionIfNeeded(final DataIntegrityViolationException dataIntegrityViolationException,
+ final Collection<YangResourceEntity> newYangResourceEntities) {
+ final Optional<DuplicatedYangResourceException> convertedException =
+ convertToDuplicatedYangResourceException(
+ dataIntegrityViolationException, newYangResourceEntities);
+ throw convertedException.isPresent() ? convertedException.get() : dataIntegrityViolationException;
+ }
+
/**
* Convert the specified data integrity violation exception into a CPS duplicated Yang resource exception
* if the cause of the error is a yang checksum database constraint violation.
return "no checksum found";
}
+ private Set<YangResourceEntity> getYangResourceEntities(final Collection<ModuleReference> moduleReferences) {
+ return moduleReferences.stream().map(moduleReference ->
+ yangResourceRepository
+ .findByModuleNameAndRevision(moduleReference.getModuleName(), moduleReference.getRevision()))
+ .collect(Collectors.toSet());
+ }
+
private static ModuleReference toModuleReference(
final YangResourceModuleReference yangResourceModuleReference) {
return ModuleReference.builder()
.dataspaceName(schemaSetEntity.getDataspace().getName()).build();
}
- private void storeAndLinkNewModules(final Map<String, String> newModuleNameToContentMap,
- final SchemaSetEntity schemaSetEntity) {
- final Set<YangResourceEntity> yangResourceEntities
- = new HashSet<>(synchronizeYangResources(newModuleNameToContentMap));
- schemaSetEntity.setYangResources(yangResourceEntities);
- schemaSetRepository.save(schemaSetEntity);
- }
-
- private void updateAllModuleReferences(final Collection<ModuleReference> allModuleReferences,
- final Integer schemaSetEntityId) {
- yangResourceRepository.deleteSchemaSetYangResourceForSchemaSetId(schemaSetEntityId);
- final List<Integer> allYangResourceIds =
- yangResourceRepository.getResourceIdsByModuleReferences(allModuleReferences);
- yangResourceRepository.insertSchemaSetIdYangResourceId(schemaSetEntityId, allYangResourceIds);
- }
-
}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2021-2025 Nordix Foundation.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.cps.ri.repository;
-
-import java.util.List;
-
-public interface SchemaSetYangResourceRepository {
-
-
- /**
- * Link yang resources (ids) with a schema set (id).
- *
- * @param schemaSetId the schema set id
- * @param yangResourceIds list of yang resource ids
- */
- void insertSchemaSetIdYangResourceId(final Integer schemaSetId, final List<Integer> yangResourceIds);
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2021-2023 Nordix Foundation.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.cps.ri.repository;
-
-import jakarta.persistence.EntityManager;
-import jakarta.persistence.PersistenceContext;
-import java.sql.PreparedStatement;
-import java.util.List;
-import org.hibernate.Session;
-import org.springframework.transaction.annotation.Transactional;
-
-@Transactional
-public class SchemaSetYangResourceRepositoryImpl implements SchemaSetYangResourceRepository {
-
- private static final int MAX_INSERT_BATCH_SIZE = 100;
-
- @PersistenceContext
- private EntityManager entityManager;
-
- @Override
- public void insertSchemaSetIdYangResourceId(final Integer schemaSetId, final List<Integer> yangResourceIds) {
- final Session session = entityManager.unwrap(Session.class);
- session.doWork(connection -> {
- try (PreparedStatement preparedStatement = connection.prepareStatement(
- "INSERT INTO SCHEMA_SET_YANG_RESOURCES (SCHEMA_SET_ID, YANG_RESOURCE_ID) VALUES ( ?, ?)")) {
- int sqlQueryCount = 1;
- for (final int yangResourceId : yangResourceIds) {
- preparedStatement.setInt(1, schemaSetId);
- preparedStatement.setInt(2, yangResourceId);
- preparedStatement.addBatch();
- if (sqlQueryCount % MAX_INSERT_BATCH_SIZE == 0 || sqlQueryCount == yangResourceIds.size()) {
- preparedStatement.executeBatch();
- }
- sqlQueryCount++;
- }
- }
- });
- }
-}
-
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2022-2023 Nordix Foundation.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.cps.ri.repository;
-
-import java.util.Collection;
-import java.util.List;
-import org.onap.cps.api.model.ModuleReference;
-
-public interface YangResourceNativeRepository {
-
- List<Integer> getResourceIdsByModuleReferences(Collection<ModuleReference> moduleReferences);
-
-}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2022-2023 Nordix Foundation.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.cps.ri.repository;
-
-import jakarta.persistence.EntityManager;
-import jakarta.persistence.PersistenceContext;
-import jakarta.persistence.Query;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.StringJoiner;
-import lombok.extern.slf4j.Slf4j;
-import org.hibernate.type.StandardBasicTypes;
-import org.onap.cps.api.model.ModuleReference;
-import org.springframework.stereotype.Repository;
-import org.springframework.transaction.annotation.Transactional;
-
-@Slf4j
-@Repository
-public class YangResourceNativeRepositoryImpl implements YangResourceNativeRepository {
-
- @PersistenceContext
- private EntityManager entityManager;
-
- @Override
- @Transactional
- public List<Integer> getResourceIdsByModuleReferences(final Collection<ModuleReference> moduleReferences) {
- if (moduleReferences.isEmpty()) {
- return Collections.emptyList();
- }
- final Query query = entityManager.createNativeQuery(getCombinedSelectSqlQuery(moduleReferences))
- .unwrap(org.hibernate.query.NativeQuery.class)
- .addScalar("id", StandardBasicTypes.INTEGER);
- final List<Integer> yangResourceIds = query.getResultList();
- if (yangResourceIds.size() != moduleReferences.size()) {
- log.warn("ModuleReferences size : {} and QueryResult size : {}", moduleReferences.size(),
- yangResourceIds.size());
- }
- return yangResourceIds;
- }
-
- private String getCombinedSelectSqlQuery(final Collection<ModuleReference> moduleReferences) {
- final StringJoiner sqlQueryJoiner = new StringJoiner(" UNION ALL ");
- moduleReferences.forEach(moduleReference ->
- sqlQueryJoiner.add(String.format("SELECT id FROM yang_resource WHERE module_name='%s' and revision='%s'",
- moduleReference.getModuleName(),
- moduleReference.getRevision()))
- );
- return sqlQueryJoiner.toString();
- }
-}
import org.springframework.stereotype.Repository;
@Repository
-public interface YangResourceRepository extends JpaRepository<YangResourceEntity, Integer>,
- YangResourceNativeRepository, SchemaSetYangResourceRepository {
+public interface YangResourceRepository extends JpaRepository<YangResourceEntity, Integer> {
+
+ YangResourceEntity findByModuleNameAndRevision(@Param("moduleName") String moduleName,
+ @Param("revision") String revision);
List<YangResourceEntity> findAllByChecksumIn(Collection<String> checksums);
@Param("dataspaceName") String dataspaceName, @Param("anchorName") String anchorName,
@Param("moduleName") String moduleName, @Param("revision") String revision);
- @Modifying
- @Query(value = "DELETE FROM schema_set_yang_resources WHERE schema_set_id = :schemaSetId", nativeQuery = true)
- void deleteSchemaSetYangResourceForSchemaSetId(@Param("schemaSetId") int schemaSetId);
-
@Modifying
@Query(value = """
DELETE FROM yang_resource WHERE NOT EXISTS (SELECT 1 FROM schema_set_yang_resources
and: 'persisting yang resource raises db constraint exception (in case of concurrent requests for example)'
mockYangResourceRepository.saveAll(_) >> { throw dbException }
when: 'attempt to store schema set '
- def newYangResourcesNameToContentMap = [(yangResourceName):yangResourceContent]
- objectUnderTest.storeSchemaSet('my-dataspace', 'my-schema-set', newYangResourcesNameToContentMap)
+ def newYangResourceContentPerName = [(yangResourceName):yangResourceContent]
+ objectUnderTest.createSchemaSet('my-dataspace', 'my-schema-set', newYangResourceContentPerName)
then: 'an #expectedThrownException is thrown'
def e = thrown(expectedThrownException)
assert e.getMessage().contains(expectedThrownExceptionMessage)
def schemaSetEntity = new SchemaSetEntity(id: 1)
mockSchemaSetRepository.getByDataspaceAndName(_, _) >> schemaSetEntity
when: 'schema set update is requested'
- objectUnderTest.updateSchemaSetFromModules('my-dataspace', 'my-schemaset', [:], [new ModuleReference('some module name', 'some revision name')])
+ objectUnderTest.updateSchemaSetFromNewAndExistingModules('my-dataspace', 'my-schemaset', [:], [new ModuleReference('some module name', 'some revision name')])
then: 'no exception is thrown '
noExceptionThrown()
}
* @param dataspaceName source dataspace name
* @param sourceAnchorName source anchor name
* @param xpath xpath
- * @param yangResourcesNameToContentMap YANG resources (files) map where key is a name and value is content
+ * @param yangResourceContentPerName YANG resources (files) map where key is a name and value is content
* @param targetData target data to be compared in JSON string format
* @param fetchDescendantsOption defines the scope of data to fetch: defaulted to INCLUDE_ALL_DESCENDANTS
* @return list containing {@link DeltaReport} objects
*/
List<DeltaReport> getDeltaByDataspaceAnchorAndPayload(String dataspaceName, String sourceAnchorName, String xpath,
- Map<String, String> yangResourcesNameToContentMap,
+ Map<String, String> yangResourceContentPerName,
String targetData,
FetchDescendantsOption fetchDescendantsOption);
*
* @param dataspaceName dataspace name
* @param schemaSetName schema set name
- * @param yangResourcesNameToContentMap yang resources (files) as a mep where key is resource name
+ * @param yangResourceContentPerName yang resources (files) as a mep where key is resource name
* and value is content
*/
void createSchemaSet(String dataspaceName, String schemaSetName,
- Map<String, String> yangResourcesNameToContentMap);
+ Map<String, String> yangResourceContentPerName);
/**
* Create or upgrade a schema set from new modules and existing modules or only existing modules.
- * @param dataspaceName Dataspace name
- * @param schemaSetName schema set name
- * @param newModuleNameToContentMap YANG resources map where key is a module name and value is content
- * @param allModuleReferences All YANG resource module references
+ * @param dataspaceName Dataspace name
+ * @param schemaSetName schema set name
+ * @param yangResourceContentPerName YANG resources map where key is a name and value is content
+ * @param allModuleReferences All YANG resource module references
*/
void createSchemaSetFromModules(String dataspaceName, String schemaSetName,
- Map<String, String> newModuleNameToContentMap,
+ Map<String, String> yangResourceContentPerName,
Collection<ModuleReference> allModuleReferences);
/**
@Override
public List<DeltaReport> getDeltaByDataspaceAnchorAndPayload(final String dataspaceName,
final String sourceAnchorName, final String xpath,
- final Map<String, String> yangResourcesNameToContentMap,
+ final Map<String, String> yangResourceContentPerName,
final String targetData,
final FetchDescendantsOption fetchDescendantsOption) {
new ArrayList<>(rebuildSourceDataNodes(xpath, sourceAnchor, sourceDataNodes));
final Collection<DataNode> targetDataNodes =
- new ArrayList<>(buildTargetDataNodes(sourceAnchor, xpath, yangResourcesNameToContentMap, targetData));
+ new ArrayList<>(buildTargetDataNodes(sourceAnchor, xpath, yangResourceContentPerName, targetData));
return cpsDeltaService.getDeltaReports(sourceDataNodesRebuilt, targetDataNodes);
}
}
private Collection<DataNode> buildTargetDataNodes(final Anchor sourceAnchor, final String xpath,
- final Map<String, String> yangResourcesNameToContentMap,
+ final Map<String, String> yangResourceContentPerName,
final String targetData) {
- if (yangResourcesNameToContentMap.isEmpty()) {
+ if (yangResourceContentPerName.isEmpty()) {
return buildDataNodesWithAnchorAndXpath(sourceAnchor, xpath, targetData, ContentType.JSON);
} else {
- return buildDataNodesWithYangResourceAndXpath(yangResourcesNameToContentMap, xpath,
+ return buildDataNodesWithYangResourceAndXpath(yangResourceContentPerName, xpath,
targetData, ContentType.JSON);
}
}
}
private Collection<DataNode> buildDataNodesWithParentNodeXpath(
- final Map<String, String> yangResourcesNameToContentMap, final String xpath,
+ final Map<String, String> yangResourceContentPerName, final String xpath,
final String nodeData, final ContentType contentType) {
if (isRootNodeXpath(xpath)) {
final ContainerNode containerNode = yangParser.parseData(contentType, nodeData,
- yangResourcesNameToContentMap, PARENT_NODE_XPATH_FOR_ROOT_NODE_XPATH);
+ yangResourceContentPerName, PARENT_NODE_XPATH_FOR_ROOT_NODE_XPATH);
final Collection<DataNode> dataNodes = new DataNodeBuilder()
.withContainerNode(containerNode)
.buildCollection();
}
final String normalizedParentNodeXpath = CpsPathUtil.getNormalizedXpath(xpath);
final ContainerNode containerNode =
- yangParser.parseData(contentType, nodeData, yangResourcesNameToContentMap, normalizedParentNodeXpath);
+ yangParser.parseData(contentType, nodeData, yangResourceContentPerName, normalizedParentNodeXpath);
final Collection<DataNode> dataNodes = new DataNodeBuilder()
.withParentNodeXpath(normalizedParentNodeXpath)
.withContainerNode(containerNode)
}
private Collection<DataNode> buildDataNodesWithYangResourceAndXpath(
- final Map<String, String> yangResourcesNameToContentMap, final String xpath,
+ final Map<String, String> yangResourceContentPerName, final String xpath,
final String nodeData, final ContentType contentType) {
if (!isRootNodeXpath(xpath)) {
final String parentNodeXpath = CpsPathUtil.getNormalizedParentXpath(xpath);
if (parentNodeXpath.isEmpty()) {
- return buildDataNodesWithParentNodeXpath(yangResourcesNameToContentMap, ROOT_NODE_XPATH,
+ return buildDataNodesWithParentNodeXpath(yangResourceContentPerName, ROOT_NODE_XPATH,
nodeData, contentType);
}
- return buildDataNodesWithParentNodeXpath(yangResourcesNameToContentMap, parentNodeXpath,
+ return buildDataNodesWithParentNodeXpath(yangResourceContentPerName, parentNodeXpath,
nodeData, contentType);
}
- return buildDataNodesWithParentNodeXpath(yangResourcesNameToContentMap, xpath, nodeData, contentType);
+ return buildDataNodesWithParentNodeXpath(yangResourceContentPerName, xpath, nodeData, contentType);
}
private static boolean isRootNodeXpath(final String xpath) {
@Timed(value = "cps.module.service.schemaset.create",
description = "Time taken to create (and store) a schemaset")
public void createSchemaSet(final String dataspaceName, final String schemaSetName,
- final Map<String, String> yangResourcesNameToContentMap) {
+ final Map<String, String> yangResourceContentPerName) {
cpsValidator.validateNameCharacters(dataspaceName);
- cpsModulePersistenceService.storeSchemaSet(dataspaceName, schemaSetName, yangResourcesNameToContentMap);
+ cpsModulePersistenceService.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName);
final YangTextSchemaSourceSet yangTextSchemaSourceSet =
- timedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourcesNameToContentMap);
+ timedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourceContentPerName);
yangTextSchemaSourceSetCache.updateCache(dataspaceName, schemaSetName, yangTextSchemaSourceSet);
}
@Override
public void createSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
- final Map<String, String> newModuleNameToContentMap,
+ final Map<String, String> yangResourceContentPerName,
final Collection<ModuleReference> allModuleReferences) {
cpsValidator.validateNameCharacters(dataspaceName);
- cpsModulePersistenceService.storeSchemaSetFromModules(dataspaceName, schemaSetName,
- newModuleNameToContentMap, allModuleReferences);
+ cpsModulePersistenceService.createSchemaSetFromNewAndExistingModules(dataspaceName, schemaSetName,
+ yangResourceContentPerName, allModuleReferences);
}
@Override
@Override
public SchemaSet getSchemaSet(final String dataspaceName, final String schemaSetName) {
cpsValidator.validateNameCharacters(dataspaceName);
- final var yangTextSchemaSourceSet = yangTextSchemaSourceSetCache
+ final YangTextSchemaSourceSet yangTextSchemaSourceSet = yangTextSchemaSourceSetCache
.get(dataspaceName, schemaSetName);
return SchemaSet.builder().name(schemaSetName).dataspaceName(dataspaceName)
.moduleReferences(yangTextSchemaSourceSet.getModuleReferences()).build();
@Override
public void upgradeSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
- final Map<String, String> newModuleNameToContentMap,
+ final Map<String, String> newYangResourceContentPerModule,
final Collection<ModuleReference> allModuleReferences) {
cpsValidator.validateNameCharacters(dataspaceName);
- cpsModulePersistenceService.updateSchemaSetFromModules(dataspaceName, schemaSetName,
- newModuleNameToContentMap, allModuleReferences);
+ cpsModulePersistenceService.updateSchemaSetFromNewAndExistingModules(dataspaceName, schemaSetName,
+ newYangResourceContentPerModule, allModuleReferences);
yangTextSchemaSourceSetCache.removeFromCache(dataspaceName, schemaSetName);
}
-
@Override
public Collection<ModuleReference> getYangResourceModuleReferences(final String dataspaceName) {
cpsValidator.validateNameCharacters(dataspaceName);
/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2023-2024 Nordix Foundation
+ * Copyright (C) 2023-2025 Nordix Foundation
* Modifications Copyright (C) 2024 TechMahindra Ltd.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
} catch (final AlreadyDefinedException alreadyDefinedException) {
log.warn("Creating new schema set failed as schema set already exists");
} catch (final Exception exception) {
- log.error("Creating schema set failed: {} ", exception.getMessage());
+ log.error("Creating schema set {} failed: {} ", schemaSetName, exception.getMessage());
throw new ModelOnboardingException("Creating schema set failed", exception.getMessage());
}
}
/**
* Stores Schema Set.
*
- * @param dataspaceName dataspace name
- * @param schemaSetName schema set name
- * @param yangResourcesNameToContentMap YANG resources (files) map where key is a name and value is content
+ * @param dataspaceName dataspace name
+ * @param schemaSetName schema set name
+ * @param yangResourceContentPerName a map of YANG resources map where key is a name and value is content
*/
- void storeSchemaSet(String dataspaceName, String schemaSetName, Map<String, String> yangResourcesNameToContentMap);
+ void createSchemaSet(String dataspaceName, String schemaSetName, Map<String, String> yangResourceContentPerName);
/**
* Stores a new schema set from new modules and existing modules.
*
- * @param dataspaceName Dataspace name
- * @param schemaSetName Schema set name
- * @param newModuleNameToContentMap YANG resources map where key is a module name and value is content
- * @param allModuleReferences All YANG resources module references
+ * @param dataspaceName dataspace name
+ * @param schemaSetName Schema set name
+ * @param newYangResourceContentPerName a map of only the new YANG resources
+ * the key is a name and value is its content
+ * @param allModuleReferences all YANG resources module references
*/
- void storeSchemaSetFromModules(String dataspaceName, String schemaSetName,
- Map<String, String> newModuleNameToContentMap, Collection<ModuleReference> allModuleReferences);
+ void createSchemaSetFromNewAndExistingModules(String dataspaceName, String schemaSetName,
+ Map<String, String> newYangResourceContentPerName,
+ Collection<ModuleReference> allModuleReferences);
/**
* Update an existing schema set from new modules and existing modules.
*
- * @param dataspaceName Dataspace name
+ * @param dataspaceName dataspace name
* @param schemaSetName Schema set name
- * @param newModuleNameToContentMap YANG resources map where key is a module name and value is content
- * @param allModuleReferences All YANG resources module references
+ * @param newYangResourcesPerName a map of only the new YANG resources
+ * the key is a module name and value is its content
+ * @param allModuleReferences all YANG resources module references
*/
- void updateSchemaSetFromModules(final String dataspaceName, final String schemaSetName,
- final Map<String, String> newModuleNameToContentMap,
- final Collection<ModuleReference> allModuleReferences);
+ void updateSchemaSetFromNewAndExistingModules(String dataspaceName, String schemaSetName,
+ Map<String, String> newYangResourcesPerName,
+ Collection<ModuleReference> allModuleReferences);
/**
* Checks whether a schema set exists in the specified dataspace.
/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2024 Nordix Foundation.
+ * Copyright (C) 2024-2025 Nordix Foundation.
* Modifications Copyright (C) 2024 TechMahindra Ltd.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
/**
* Parses data into (normalized) ContainerNode according to schema context for the given yang resource.
*
- * @param nodeData data string
- * @param yangResourcesNameToContentMap yang resource to content map
- * @return the NormalizedNode object
+ * @param nodeData data string
+ * @param yangResourceContentPerName yang resource content per name
+ * @return the NormalizedNode object
*/
@Timed(value = "cps.utils.yangparser.nodedata.with.parent.with.yangResourceMap.parse",
description = "Time taken to parse node data with a parent")
public ContainerNode parseData(final ContentType contentType,
final String nodeData,
- final Map<String, String> yangResourcesNameToContentMap,
+ final Map<String, String> yangResourceContentPerName,
final String parentNodeXpath) {
- final SchemaContext schemaContext = getSchemaContext(yangResourcesNameToContentMap);
+ final SchemaContext schemaContext = getSchemaContext(yangResourceContentPerName);
return yangParserHelper.parseData(contentType, nodeData, schemaContext, parentNodeXpath, VALIDATE_AND_PARSE);
}
anchor.getSchemaSetName()).getSchemaContext();
}
- private SchemaContext getSchemaContext(final Map<String, String> yangResourcesNameToContentMap) {
- return timedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourcesNameToContentMap)
+ private SchemaContext getSchemaContext(final Map<String, String> yangResourceContentPerName) {
+ return timedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourceContentPerName)
.getSchemaContext();
}
@Timed(value = "cps.yangtextschemasourceset.build",
description = "Time taken to build a yang text schema source set")
public YangTextSchemaSourceSet getYangTextSchemaSourceSet(
- final Map<String, String> yangResourcesNameToContentMap) {
- return YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap);
+ final Map<String, String> yangResourceContentPerName) {
+ return YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName);
}
}
def 'Get delta between anchor and payload with user provided schema #scenario'() {
given: 'user provided schema set '
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- setupSchemaSetMocksForDelta(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ setupSchemaSetMocksForDelta(yangResourceContentPerName)
when: 'attempt to get delta between an anchor and a JSON payload'
- objectUnderTest.getDeltaByDataspaceAnchorAndPayload(dataspaceName, anchorName, xpath, yangResourcesNameToContentMap, jsonData, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS)
+ objectUnderTest.getDeltaByDataspaceAnchorAndPayload(dataspaceName, anchorName, xpath, yangResourceContentPerName, jsonData, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS)
then: 'dataspacename and anchor names are validated'
1 * mockCpsValidator.validateNameCharacters(['some-dataspace', 'some-anchor'])
and: 'source data nodes are fetched using appropriate persistence layer method'
def 'Delta between anchor and payload error scenario #scenario'() {
given: 'schema set for given anchor and dataspace references bookstore model'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- setupSchemaSetMocksForDelta(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ setupSchemaSetMocksForDelta(yangResourceContentPerName)
when: 'attempt to get delta between anchor and payload'
- objectUnderTest.getDeltaByDataspaceAnchorAndPayload(dataspaceName, anchorName, xpath, yangResourcesNameToContentMap, jsonData, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS)
+ objectUnderTest.getDeltaByDataspaceAnchorAndPayload(dataspaceName, anchorName, xpath, yangResourceContentPerName, jsonData, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS)
then: 'expected exception is thrown'
thrown(DataValidationException)
where: 'following parameters were used'
mockYangTextSchemaSourceSet.getSchemaContext() >> schemaContext
}
- def setupSchemaSetMocksForDelta(Map<String, String> yangResourcesNameToContentMap) {
+ def setupSchemaSetMocksForDelta(Map<String, String> yangResourceContentPerName) {
def mockYangTextSchemaSourceSet = Mock(YangTextSchemaSourceSet)
- mockTimedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourcesNameToContentMap) >> mockYangTextSchemaSourceSet
+ mockTimedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourceContentPerName) >> mockYangTextSchemaSourceSet
mockYangTextSchemaSourceSetCache.get(_, _) >> mockYangTextSchemaSourceSet
- def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap).getSchemaContext()
+ def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName).getSchemaContext()
mockYangTextSchemaSourceSet.getSchemaContext() >> schemaContext
}
when: 'Create schema set method is invoked'
objectUnderTest.createSchemaSet('someDataspace', 'schemaSetName@with Special!Characters', [:])
then: 'Parameters are validated and processing is delegated to persistence service'
- 1 * mockCpsModulePersistenceService.storeSchemaSet('someDataspace', 'schemaSetName@with Special!Characters', [:])
+ 1 * mockCpsModulePersistenceService.createSchemaSet('someDataspace', 'schemaSetName@with Special!Characters', [:])
and: 'the CpsValidator is called on the dataspaceName'
1 * mockCpsValidator.validateNameCharacters('someDataspace')
}
when: 'create schema set from modules method is invoked'
objectUnderTest.createSchemaSetFromModules('someDataspaceName', 'someSchemaSetName', [newModule: 'newContent'], listOfExistingModulesModuleReference)
then: 'processing is delegated to persistence service'
- 1 * mockCpsModulePersistenceService.storeSchemaSetFromModules('someDataspaceName', 'someSchemaSetName', [newModule: 'newContent'], listOfExistingModulesModuleReference)
+ 1 * mockCpsModulePersistenceService.createSchemaSetFromNewAndExistingModules('someDataspaceName', 'someSchemaSetName', [newModule: 'newContent'], listOfExistingModulesModuleReference)
and: 'the CpsValidator is called on the dataspaceName'
1 * mockCpsValidator.validateNameCharacters('someDataspaceName')
}
def 'Create schema set from invalid resources'() {
given: 'Invalid yang resource as name-to-content map'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('invalid.yang')
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('invalid.yang')
when: 'Create schema set method is invoked'
- objectUnderTest.createSchemaSet('someDataspace', 'someSchemaSet', yangResourcesNameToContentMap)
+ objectUnderTest.createSchemaSet('someDataspace', 'someSchemaSet', yangResourceContentPerName)
then: 'Model validation exception is thrown'
thrown(ModelValidationException)
}
def 'Create schema set with duplicate yang resource exception in persistence layer.'() {
given: 'the persistence layer throws an duplicated yang resource exception'
def originalException = new DuplicatedYangResourceException('name', '123', null)
- mockCpsModulePersistenceService.storeSchemaSet(*_) >> { throw originalException }
+ mockCpsModulePersistenceService.createSchemaSet(*_) >> { throw originalException }
when: 'attempt to create schema set'
objectUnderTest.createSchemaSet('someDataspace', 'someSchemaSet', [:])
then: 'the same duplicated yang resource exception is thrown (up)'
def 'Get schema set by name and dataspace.'() {
given: 'an already present schema set'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
and: 'yang resource cache returns the expected schema set'
- mockYangTextSchemaSourceSetCache.get('someDataspace', 'schemaSetName@with Special!Characters') >> YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ mockYangTextSchemaSourceSetCache.get('someDataspace', 'schemaSetName@with Special!Characters') >> YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
when: 'get schema set method is invoked'
def result = objectUnderTest.getSchemaSet('someDataspace', 'schemaSetName@with Special!Characters')
then: 'the correct schema set is returned'
/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2024 Nordix Foundation.
+ * Copyright (C) 2021-2025 Nordix Foundation.
* Modifications Copyright (C) 2021-2022 Bell Canada.
* Modifications Copyright (C) 2021 Pantheon.tech
* Modifications Copyright (C) 2022-2024 TechMahindra Ltd.
def 'E2E model can be parsed by CPS.'() {
given: 'Valid yang resource as name-to-content map'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap(
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap(
'ietf/ietf-inet-types@2013-07-15.yang',
'ietf/ietf-yang-types@2013-07-15.yang',
'e2e/basic/ran-network2020-08-06.yang'
)
when: 'Create schema set method is invoked'
- cpsModuleServiceImpl.createSchemaSet(dataspaceName, schemaSetName, yangResourcesNameToContentMap)
+ cpsModuleServiceImpl.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName)
then: 'Parameters are validated and processing is delegated to persistence service'
- 1 * mockModuleStoreService.storeSchemaSet(dataspaceName, schemaSetName, yangResourcesNameToContentMap)
+ 1 * mockModuleStoreService.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName)
}
def 'E2E Coverage Area-Tracking Area & TA-Cell mapping model can be parsed by CPS.'() {
given: 'Valid yang resource as name-to-content map'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap(
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap(
'e2e/basic/cps-cavsta-onap-internal2021-01-28.yang')
when: 'Create schema set method is invoked'
- cpsModuleServiceImpl.createSchemaSet(dataspaceName, schemaSetName, yangResourcesNameToContentMap)
+ cpsModuleServiceImpl.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName)
then: 'Parameters are validated and processing is delegated to persistence service'
- 1 * mockModuleStoreService.storeSchemaSet(dataspaceName, schemaSetName, yangResourcesNameToContentMap)
+ 1 * mockModuleStoreService.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName)
}
def 'E2E Coverage Area-Tracking Area & TA-Cell mapping data can be parsed by CPS.'() {
given: 'Valid yang resource as name-to-content map'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap(
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap(
'e2e/basic/cps-cavsta-onap-internal2021-01-28.yang')
- def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap).getSchemaContext()
+ def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName).getSchemaContext()
def dataNodeStored
and : 'a valid json is provided for the model'
def jsonData = TestUtils.getResourceFileContent('e2e/basic/cps-Cavsta-Data.txt')
mockCpsAnchorService.getAnchor(dataspaceName, anchorName) >>
new Anchor().builder().name(anchorName).schemaSetName(schemaSetName).dataspaceName(dataspaceName).build()
mockYangTextSchemaSourceSetCache.get(dataspaceName, schemaSetName) >>
- YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
mockModuleStoreService.getYangSchemaResources(dataspaceName, schemaSetName) >> schemaContext
when: 'saveData method is invoked'
cpsDataServiceImpl.saveData(dataspaceName, anchorName, jsonData, noTimestamp)
def 'E2E Coverage Area-Tracking Area & TA-Cell mapping data can be parsed for RAN inventory.'() {
def dataNodeStored
given: 'valid yang resource as name-to-content map'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap(
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap(
'e2e/basic/cps-ran-inventory@2021-01-28.yang')
- def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap).getSchemaContext()
+ def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName).getSchemaContext()
and : 'a valid json is provided for the model'
def jsonData = TestUtils.getResourceFileContent('e2e/basic/cps-ran-inventory-data.json')
and : 'all the further dependencies are mocked '
mockCpsAnchorService.getAnchor('someDataspace', 'someAnchor') >>
new Anchor().builder().name('someAnchor').schemaSetName('someSchemaSet').dataspaceName(dataspaceName).build()
- mockYangTextSchemaSourceSetCache.get('someDataspace', 'someSchemaSet') >> YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ mockYangTextSchemaSourceSetCache.get('someDataspace', 'someSchemaSet') >> YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
mockModuleStoreService.getYangSchemaResources('someDataspace', 'someSchemaSet') >> schemaContext
when: 'saveData method is invoked'
cpsDataServiceImpl.saveData('someDataspace', 'someAnchor', jsonData, noTimestamp)
def 'E2E RAN Schema Model.'(){
given: 'yang resources'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap(
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap(
'ietf/ietf-inet-types@2013-07-15.yang',
'ietf/ietf-yang-types@2013-07-15.yang',
'e2e/basic/cps-ran-schema-model@2021-05-19.yang'
and : 'json data'
def jsonData = TestUtils.getResourceFileContent('e2e/basic/cps-ran-schema-model-data-v4.json')
expect: 'schema context is built with no exception indicating the schema set being valid '
- def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap).getSchemaContext()
+ def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName).getSchemaContext()
and: 'data is parsed with no exception indicating the model match'
new YangParserHelper().parseData(ContentType.JSON, jsonData, schemaContext, '', false) != null
}
given: 'cache is empty'
yangResourceCacheImpl.clear()
and: 'a schema set exists'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- def expectedYangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def expectedYangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
when: 'schema-set information is asked'
def result = objectUnderTest.get('my-dataspace', 'my-schemaset')
then: 'information fetched from cps module persistence'
1 * mockModuleStoreService.getYangSchemaResources('my-dataspace', 'my-schemaset')
- >> yangResourcesNameToContentMap
+ >> yangResourceContentPerName
and: 'stored in the cache'
def cachedValue = getCachedValue('my-dataspace', 'my-schemaset')
assert cachedValue.getModuleReferences() == expectedYangTextSchemaSourceSet.getModuleReferences()
def 'Cache Hit: Respond from cache'() {
given: 'a schema set exists'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- def expectedYangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def expectedYangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
and: 'stored in cache'
yangResourceCacheImpl.put(getCacheKey('my-dataspace', 'my-schemaset'), expectedYangTextSchemaSourceSet)
when: 'schema-set information is asked'
def 'Cache Update: when no data exist in the cache'() {
given: 'a schema set exists'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- def yangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def yangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
when: 'cache is updated'
objectUnderTest.updateCache('my-dataspace', 'my-schemaset', yangTextSchemaSourceSet)
then: 'cached value is same as expected'
def 'Cache Evict:with invalid #scenario'() {
given: 'a schema set exists in cache'
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
- def yangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap)
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def yangTextSchemaSourceSet = YangTextSchemaSourceSetBuilder.of(yangResourceContentPerName)
yangResourceCacheImpl.put(getCacheKey('my-dataspace', 'my-schemaset'), yangTextSchemaSourceSet)
def cachedValue = getCachedValue('my-dataspace', 'my-schemaset')
assert cachedValue.getModuleReferences() == yangTextSchemaSourceSet.getModuleReferences()
def objectUnderTest = new YangParser(mockYangParserHelper, mockYangTextSchemaSourceSetCache, mockTimedYangTextSchemaSourceSetBuilder)
def anchor = new Anchor(dataspaceName: 'my dataspace', schemaSetName: 'my schema')
- def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang')
+ def yangResourceContentPerName = TestUtils.getYangResourcesAsMap('bookstore.yang')
def mockYangTextSchemaSourceSet = Mock(YangTextSchemaSourceSet)
def mockSchemaContext = Mock(SchemaContext)
def containerNodeFromYangUtils = Mock(ContainerNode)
def 'Parsing data with yang resource to context map.'() {
given: 'the schema source set for the yang resource map is returned'
- mockTimedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourcesNameToContentMap) >> mockYangTextSchemaSourceSet
+ mockTimedYangTextSchemaSourceSetBuilder.getYangTextSchemaSourceSet(yangResourceContentPerName) >> mockYangTextSchemaSourceSet
when: 'parsing some json data'
- def result = objectUnderTest.parseData(ContentType.JSON, 'some json', yangResourcesNameToContentMap, noParent)
+ def result = objectUnderTest.parseData(ContentType.JSON, 'some json', yangResourceContentPerName, noParent)
then: 'the yang parser helper always returns a container node'
1 * mockYangParserHelper.parseData(ContentType.JSON, 'some json', mockSchemaContext, noParent, validateAndParse) >> containerNodeFromYangUtils
and: 'the result is the same container node as return from yang utils'
import org.onap.cps.ncmp.impl.inventory.sync.ModuleSyncWatchdog
import org.onap.cps.ncmp.impl.utils.AlternateIdMatcher
import org.onap.cps.ri.repository.DataspaceRepository
+import org.onap.cps.ri.repository.SchemaSetRepository
import org.onap.cps.ri.utils.SessionManager
import org.onap.cps.utils.JsonObjectMapper
import org.springframework.beans.factory.annotation.Autowired
@Autowired
SessionManager sessionManager
+ @Autowired
+ DataspaceRepository dataspaceRepository
+
+ @Autowired
+ SchemaSetRepository schemaSetRepository
+
@Autowired
ParameterizedCmHandleQueryService networkCmProxyCmHandleQueryService
return nodeCount
}
- def getBookstoreYangResourcesNameToContentMap() {
+ def getBookstoreyangResourceContentPerName() {
def bookstoreModelFileContent = readResourceDataFile('bookstore/bookstore.yang')
def bookstoreTypesFileContent = readResourceDataFile('bookstore/bookstore-types.yang')
return [bookstore: bookstoreModelFileContent, bookstoreTypes: bookstoreTypesFileContent]
}
def createStandardBookStoreSchemaSet(targetDataspace) {
- cpsModuleService.createSchemaSet(targetDataspace, BOOKSTORE_SCHEMA_SET, getBookstoreYangResourcesNameToContentMap())
+ cpsModuleService.createSchemaSet(targetDataspace, BOOKSTORE_SCHEMA_SET, getBookstoreyangResourceContentPerName())
}
def createStandardBookStoreSchemaSet(targetDataspace, targetSchemaSet) {
- cpsModuleService.createSchemaSet(targetDataspace, targetSchemaSet, getBookstoreYangResourcesNameToContentMap())
+ cpsModuleService.createSchemaSet(targetDataspace, targetSchemaSet, getBookstoreyangResourceContentPerName())
}
def dataspaceExists(dataspaceName) {
import org.springframework.http.MediaType
import java.util.regex.Matcher
+import java.util.stream.Collectors
import static org.onap.cps.integration.base.CpsIntegrationSpecBase.readResourceDataFile
// get module resources for a CM-handle
case ~'^/dmi/v1/ch/(.*)/moduleResources$':
def cmHandleId = Matcher.lastMatcher[0][1]
- return getModuleResourcesResponse(cmHandleId)
+ return getModuleResourcesResponse(request, cmHandleId)
// pass-through data operation for a CM-handle
case ~'^/dmi/v1/ch/(.*)/data/ds/(.*)$':
return mockResponseWithBody(HttpStatus.OK, moduleReferences)
}
- def getModuleResourcesResponse(cmHandleId) {
- def moduleResources = '[' + getModuleNamesForCmHandle(cmHandleId).collect {
+ def getModuleResourcesResponse(request, cmHandleId) {
+ def moduleResourcesRequest = jsonSlurper.parseText(request.getBody().readUtf8())
+ def requestedModuleNames = moduleResourcesRequest.get('data').get('modules').collect{it.get('name')}
+ def candidateModuleNames = getModuleNamesForCmHandle(cmHandleId)
+ def moduleNames = candidateModuleNames.stream().filter(candidate -> requestedModuleNames.contains(candidate)).toList()
+
+ def moduleResources = '[' + moduleNames.collect {
MODULE_RESOURCES_RESPONSE_TEMPLATE.replaceAll("<MODULE_NAME>", it)
}.join(',') + ']'
return mockResponseWithBody(HttpStatus.OK, moduleResources)
}
"""
- def newYangResourcesNameToContentMap = [:]
- def moduleReferences = []
+ def yangResourceContentPerName = [:]
+ def allModuleReferences = []
def noNewModules = [:]
def bookstoreModelFileContent = readResourceDataFile('bookstore/bookstore.yang')
def bookstoreTypesFileContent = readResourceDataFile('bookstore/bookstore-types.yang')
def 'Create new schema set from yang resources with #scenario'() {
given: 'a new schema set with #numberOfModules modules'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfNewModules)
+ populateYangResourceContentPerNameAndAllModuleReferences(numberOfNewModules)
when: 'the new schema set is created'
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', newYangResourcesNameToContentMap)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', yangResourceContentPerName)
then: 'the number of module references has increased by #numberOfNewModules'
def yangResourceModuleReferences = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1)
originalNumberOfModuleReferences + numberOfNewModules == yangResourceModuleReferences.size()
def 'Create new schema set from modules with #scenario'() {
given: 'a new schema set with #numberOfNewModules modules'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfNewModules)
+ populateYangResourceContentPerNameAndAllModuleReferences(numberOfNewModules)
and: 'add existing module references (optional)'
- moduleReferences.addAll(existingModuleReferences)
+ allModuleReferences.addAll(existingModuleReferences)
when: 'the new schema set is created'
def schemaSetName = "NewSchemaWith${numberOfNewModules}Modules"
- objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, schemaSetName, newYangResourcesNameToContentMap, moduleReferences)
+ objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, schemaSetName, yangResourceContentPerName, allModuleReferences)
and: 'associated with a new anchor'
cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, schemaSetName, 'newAnchor')
then: 'the new anchor has the correct number of modules'
def yangResourceModuleReferences = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'newAnchor')
assert expectedNumberOfModulesForAnchor == yangResourceModuleReferences.size()
+ and: 'the schema set has the correct number of modules too'
+ def dataspaceEntity = dataspaceRepository.getByName(FUNCTIONAL_TEST_DATASPACE_1)
+ def schemaSetEntity = schemaSetRepository.getByDataspaceAndName(dataspaceEntity, schemaSetName)
+ assert expectedNumberOfModulesForAnchor == schemaSetEntity.yangResources.size()
cleanup:
objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, [ schemaSetName.toString() ])
where: 'the following module references are provided'
scenario | numberOfNewModules | existingModuleReferences || expectedNumberOfModulesForAnchor
'empty schema set' | 0 | [ ] || 0
- 'one existing module' | 0 | [bookStoreModuleReference ] || 1
+ 'one existing module' | 0 | [ bookStoreModuleReference ] || 1
'two new modules' | 2 | [ ] || 2
- 'two new modules, one existing' | 2 | [bookStoreModuleReference ] || 3
+ 'two new modules, one existing' | 2 | [ bookStoreModuleReference ] || 3
'over max batch size #modules' | 101 | [ ] || 101
'two valid, one invalid module' | 2 | [ new ModuleReference('NOT EXIST','IRRELEVANT') ] || 2
}
def 'Duplicate schema content.'() {
given: 'a map of yang resources'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
+ populateYangResourceContentPerNameAndAllModuleReferences(1)
when: 'a new schema set is created'
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', newYangResourcesNameToContentMap)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', yangResourceContentPerName)
then: 'the dataspace has one new module (reference)'
def numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).size()
assert numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded == originalNumberOfModuleReferences + 1
when: 'a second new schema set is created'
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema2', newYangResourcesNameToContentMap)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema2', yangResourceContentPerName)
then: 'the dataspace has no additional module (reference)'
assert numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded == objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).size()
cleanup:
def 'Attempt to create schema set, error scenario: #scenario.'() {
when: 'attempt to store schema set #schemaSetName in dataspace #dataspaceName'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(0)
- objectUnderTest.createSchemaSet(dataspaceName, schemaSetName, newYangResourcesNameToContentMap)
+ populateYangResourceContentPerNameAndAllModuleReferences(0)
+ objectUnderTest.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentPerName)
then: 'an #expectedException is thrown'
thrown(expectedException)
where: 'the following data is used'
def 'Attempt to create duplicate schema set from modules.'() {
when: 'attempt to store duplicate schema set from modules'
- objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_SCHEMA_SET, newYangResourcesNameToContentMap, [])
+ objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_SCHEMA_SET, yangResourceContentPerName, [])
then: 'an Already Defined Exception is thrown'
thrown(AlreadyDefinedException)
}
def 'Identifying new module references with #scenario'() {
when: 'identifyNewModuleReferences is called'
- def result = objectUnderTest.identifyNewModuleReferences(moduleReferences)
+ def result = objectUnderTest.identifyNewModuleReferences(allModuleReferences)
then: 'the correct module references are returned'
assert result.size() == expectedResult.size()
assert result.containsAll(expectedResult)
where: 'the following data is used'
- scenario | moduleReferences || expectedResult
+ scenario | allModuleReferences || expectedResult
'just new module references' | [new ModuleReference('new1', 'r1'), new ModuleReference('new2', 'r1')] || [new ModuleReference('new1', 'r1'), new ModuleReference('new2', 'r1')]
'one new module,one existing reference' | [new ModuleReference('new1', 'r1'), bookStoreModuleReference] || [new ModuleReference('new1', 'r1')]
'no new module references' | [bookStoreModuleReference] || []
def 'Retrieve all schema sets.'() {
given: 'an extra schema set is stored'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', newYangResourcesNameToContentMap)
+ populateYangResourceContentPerNameAndAllModuleReferences(1)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', yangResourceContentPerName)
when: 'all schema sets are retrieved'
def result = objectUnderTest.getSchemaSets(FUNCTIONAL_TEST_DATASPACE_1)
then: 'the result contains all expected schema sets'
def 'Delete schema sets with(out) cascade.'() {
given: 'a schema set'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', newYangResourcesNameToContentMap)
+ populateYangResourceContentPerNameAndAllModuleReferences(1)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', yangResourceContentPerName)
and: 'optionally create anchor for the schema set'
if (associateWithAnchor) {
cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', 'newAnchor')
def 'Delete schema sets with shared resources.'() {
given: 'a new schema set'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet1', newYangResourcesNameToContentMap)
+ populateYangResourceContentPerNameAndAllModuleReferences(1)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet1', yangResourceContentPerName)
and: 'another schema set which shares one yang resource (module)'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences(2)
- objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet2', newYangResourcesNameToContentMap)
+ populateYangResourceContentPerNameAndAllModuleReferences(2)
+ objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet2', yangResourceContentPerName)
when: 'all schema sets are retrieved'
def moduleRevisions = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).revision
then: 'both modules (revisions) are present'
U P G R A D E
*/
- def 'Upgrade schema set (with existing and new modules, no matching module set tag in NCMP)'() {
+ def 'Upgrade schema set [with existing and new modules, no matching module set tag in NCMP]'() {
given: 'an anchor and schema set with 2 modules (to be upgraded)'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences('original', 2)
- objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, [])
+ populateYangResourceContentPerNameAndAllModuleReferences('original', 2)
+ objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', yangResourceContentPerName, allModuleReferences)
cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', 'targetAnchor')
def yangResourceModuleReferencesBeforeUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
assert yangResourceModuleReferencesBeforeUpgrade.size() == 2
assert yangResourceModuleReferencesBeforeUpgrade.containsAll([new ModuleReference('original_0','2000-01-01'),new ModuleReference('original_1','2001-01-01')])
and: 'two new 2 modules (from node)'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences('new', 2)
+ populateYangResourceContentPerNameAndAllModuleReferences('new', 2)
def newModuleReferences = [new ModuleReference('new_0','2000-01-01'),new ModuleReference('new_1','2001-01-01')]
and: 'a list of all module references (normally retrieved from node)'
- def allModuleReferences = []
- allModuleReferences.add(bookStoreModuleReference)
- allModuleReferences.addAll(newModuleReferences)
+ def allOtherModuleReferences = []
+ allOtherModuleReferences.add(bookStoreModuleReference)
+ allOtherModuleReferences.addAll(newModuleReferences)
when: 'the schema set is upgraded'
- objectUnderTest.upgradeSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, allModuleReferences)
+ objectUnderTest.upgradeSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', yangResourceContentPerName, allOtherModuleReferences)
then: 'the new anchor has the correct new and existing modules'
def yangResourceModuleReferencesAfterUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
assert yangResourceModuleReferencesAfterUpgrade.size() == 3
objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['targetSchema'])
}
- def 'Upgrade existing schema set from another anchor (used in NCMP for matching module set tag)'() {
+ def 'Upgrade existing schema set from another anchor [used in NCMP for matching module set tag]'() {
given: 'an anchor and schema set with 1 module (target)'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences('target', 1)
- objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, [])
+ populateYangResourceContentPerNameAndAllModuleReferences('target', 1)
+ objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', yangResourceContentPerName, allModuleReferences)
cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', 'targetAnchor')
def moduleReferencesBeforeUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
assert moduleReferencesBeforeUpgrade.size() == 1
and: 'another anchor and schema set with 2 other modules (source for upgrade)'
- populateNewYangResourcesNameToContentMapAndAllModuleReferences('source', 2)
- objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'sourceSchema', newYangResourcesNameToContentMap, [])
+ populateYangResourceContentPerNameAndAllModuleReferences('source', 2)
+ objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'sourceSchema', yangResourceContentPerName, allModuleReferences)
cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'sourceSchema', 'sourceAnchor')
- assert objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'sourceAnchor').size() == 2
+ def yangResourcesModuleReferences = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'sourceAnchor')
+ assert yangResourcesModuleReferences.size() == 2
when: 'the target schema is upgraded using the module references from the source anchor'
def moduleReferencesFromSourceAnchor = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'sourceAnchor')
objectUnderTest.upgradeSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', noNewModules, moduleReferencesFromSourceAnchor)
H E L P E R M E T H O D S
*/
- def populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfModules) {
- populateNewYangResourcesNameToContentMapAndAllModuleReferences('name', numberOfModules)
+ def populateYangResourceContentPerNameAndAllModuleReferences(numberOfModules) {
+ populateYangResourceContentPerNameAndAllModuleReferences('name', numberOfModules)
}
- def populateNewYangResourcesNameToContentMapAndAllModuleReferences(namePrefix, numberOfModules) {
+ def populateYangResourceContentPerNameAndAllModuleReferences(namePrefix, numberOfModules) {
+ yangResourceContentPerName.clear()
+ allModuleReferences.clear()
numberOfModules.times {
def uniqueName = namePrefix + '_' + it
def uniqueRevision = String.valueOf(2000 + it) + '-01-01'
- moduleReferences.add(new ModuleReference(uniqueName, uniqueRevision))
+ allModuleReferences.add(new ModuleReference(uniqueName, uniqueRevision))
def uniqueContent = NEW_RESOURCE_CONTENT.replace(NEW_RESOURCE_REVISION, uniqueRevision).replace('module test_module', 'module '+uniqueName)
- newYangResourcesNameToContentMap.put(uniqueRevision, uniqueContent)
+ yangResourceContentPerName.put(uniqueName, uniqueContent)
}
}
def 'Store new schema set with many modules'() {
when: 'a new schema set with 200 modules is stored'
- def newYangResourcesNameToContentMap = [:]
+ def newYangResourceContentPerName = [:]
(1..200).each {
def year = 2000 + it
def resourceName = "module${it}".toString()
def moduleName = "stores${it}"
def content = NEW_RESOURCE_CONTENT.replace('2020',String.valueOf(year)).replace('stores',moduleName)
- newYangResourcesNameToContentMap.put(resourceName, content)
+ newYangResourceContentPerName.put(resourceName, content)
}
- objectUnderTest.createSchemaSet(CPS_PERFORMANCE_TEST_DATASPACE, 'perfSchemaSet', newYangResourcesNameToContentMap)
+ objectUnderTest.createSchemaSet(CPS_PERFORMANCE_TEST_DATASPACE, 'perfSchemaSet', newYangResourceContentPerName)
then: 'the schema set is persisted correctly'
def result = cpsModuleService.getSchemaSet(CPS_PERFORMANCE_TEST_DATASPACE, 'perfSchemaSet')
result.moduleReferences.size() == 200
Code Review / cps.git / commitdiff