package org.opendaylight.yangtools.yang.data.impl.leafref.context;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertThrows;
-import java.util.Set;
-import org.apache.log4j.BasicConfigurator;
+import java.util.Map;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefContext;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefDataValidationFailedException;
import org.opendaylight.yangtools.yang.data.impl.leafref.LeafRefValidation;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DataTreeCandidateValidatorTest2 {
- private static SchemaContext context;
+ private static EffectiveModelContext context;
private static Module mainModule;
private static QNameModule rootModuleQname;
private static LeafRefContext rootLeafRefContext;
private static QName devices;
private static QName device;
- private static QName typeChoice;
private static QName typeText;
private static QName devDesc;
private static QName sn;
private static QName desc;
private static final Logger LOG = LoggerFactory.getLogger(DataTreeCandidateValidatorTest2.class);
- private static final String NEW_LINE = System.getProperty("line.separator");
-
- static {
- BasicConfigurator.configure();
- }
@BeforeClass
- public static void init() {
+ public static void init() throws DataValidationFailedException {
context = YangParserTestUtils.parseYangResourceDirectory("/leafref-validation");
- final Set<Module> modules = context.getModules();
- for (final Module module : modules) {
+ for (final Module module : context.getModules()) {
if (module.getName().equals("leafref-validation2")) {
mainModule = module;
}
inMemoryDataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_OPERATIONAL, context);
final DataTreeModification initialDataTreeModification = inMemoryDataTree.takeSnapshot().newModification();
- final ContainerSchemaNode chipsListContSchemaNode = (ContainerSchemaNode) mainModule.getDataChildByName(chips);
- final ContainerNode chipsContainer = createChipsContainer(chipsListContSchemaNode);
- final YangInstanceIdentifier path1 = YangInstanceIdentifier.of(chips);
- initialDataTreeModification.write(path1, chipsContainer);
-
- final ContainerSchemaNode devTypesListContSchemaNode = (ContainerSchemaNode) mainModule
- .getDataChildByName(deviceTypeStr);
- final ContainerNode deviceTypesContainer = createDevTypeStrContainer(devTypesListContSchemaNode);
- final YangInstanceIdentifier path2 = YangInstanceIdentifier.of(deviceTypeStr);
- initialDataTreeModification.write(path2, deviceTypesContainer);
+ initialDataTreeModification.write(YangInstanceIdentifier.of(chips), Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(chips))
+ .addChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(chip))
+ .addChild(createChipsListEntry("dev_type_1", "desc1"))
+ .addChild(createChipsListEntry("dev_type_2", "desc2"))
+ .build())
+ .build());
+
+ initialDataTreeModification.write(YangInstanceIdentifier.of(deviceTypeStr), Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(deviceTypeStr))
+ .addChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(deviceType))
+ .addChild(createDevTypeListEntry("dev_type_1", "typedesc1"))
+ .addChild(createDevTypeListEntry("dev_type_2", "typedesc2"))
+ .addChild(createDevTypeListEntry("dev_type_3", "typedesc3"))
+ .build())
+ .build());
initialDataTreeModification.ready();
final DataTreeCandidate writeChipsCandidate = inMemoryDataTree.prepare(initialDataTreeModification);
}
@Test
- public void dataTreeCanditateValidationTest2() {
-
+ public void dataTreeCanditateValidationTest2() throws DataValidationFailedException {
writeDevices();
}
- private static void writeDevices() {
-
- final ContainerSchemaNode devicesContSchemaNode = (ContainerSchemaNode) mainModule.getDataChildByName(devices);
-
- final ContainerNode devicesContainer = createDevicesContainer(devicesContSchemaNode);
-
- final YangInstanceIdentifier devicesPath = YangInstanceIdentifier.of(devices);
+ private static void writeDevices() throws DataValidationFailedException {
final DataTreeModification writeModification = inMemoryDataTree.takeSnapshot().newModification();
- writeModification.write(devicesPath, devicesContainer);
+ writeModification.write(YangInstanceIdentifier.of(devices), Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(devices))
+ .addChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(device))
+ .addChild(createDeviceListEntry("dev_type_1", "typedesc1", 123456, "192.168.0.1"))
+ .addChild(createDeviceListEntry("dev_type_2", "typedesc2", 123457, "192.168.0.1"))
+ .addChild(createDeviceListEntry("dev_type_2", "typedesc3", 123457, "192.168.0.1"))
+ .addChild(createDeviceListEntry("dev_type_1", "typedesc2", 123458, "192.168.0.1"))
+ .addChild(createDeviceListEntry("unknown", "unknown", 123457, "192.168.0.1"))
+ .build())
+ .build());
writeModification.ready();
final DataTreeCandidate writeDevicesCandidate = inMemoryDataTree.prepare(writeModification);
LOG.debug("*************************");
LOG.debug("{}", inMemoryDataTree);
- boolean exception = false;
- try {
- LeafRefValidation.validate(writeDevicesCandidate, rootLeafRefContext);
- } catch (final LeafRefDataValidationFailedException e) {
- LOG.debug("All validation errors:{}{}", NEW_LINE, e.getMessage());
-
- assertEquals(4, e.getValidationsErrorsCount());
- exception = true;
- }
-
- assertTrue(exception);
+ final LeafRefDataValidationFailedException ex = assertThrows(LeafRefDataValidationFailedException.class,
+ () -> LeafRefValidation.validate(writeDevicesCandidate, rootLeafRefContext));
+ assertEquals(4, ex.getValidationsErrorsCount());
inMemoryDataTree.commit(writeDevicesCandidate);
LOG.debug("{}", inMemoryDataTree);
}
- private static ContainerNode createDevTypeStrContainer(final ContainerSchemaNode container) {
-
- final ListSchemaNode devTypeListSchemaNode = (ListSchemaNode) container.getDataChildByName(deviceType);
-
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> devTypeContainerBldr = Builders
- .containerBuilder(container);
-
- final MapNode devTypeMap = createDevTypeList(devTypeListSchemaNode);
- devTypeContainerBldr.addChild(devTypeMap);
-
- return devTypeContainerBldr.build();
- }
-
- private static MapNode createDevTypeList(final ListSchemaNode devTypeListSchemaNode) {
-
- final CollectionNodeBuilder<MapEntryNode, MapNode> devTypeMapBldr = Builders.mapBuilder(devTypeListSchemaNode);
-
- devTypeMapBldr.addChild(createDevTypeListEntry("dev_type_1", "typedesc1", devTypeListSchemaNode));
- devTypeMapBldr.addChild(createDevTypeListEntry("dev_type_2", "typedesc2", devTypeListSchemaNode));
- devTypeMapBldr.addChild(createDevTypeListEntry("dev_type_3", "typedesc3", devTypeListSchemaNode));
-
- return devTypeMapBldr.build();
+ private static MapEntryNode createDevTypeListEntry(final String typeVal, final String descVal) {
+ return Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(deviceType, type, typeVal))
+ .addChild(ImmutableNodes.leafNode(type, typeVal))
+ .addChild(ImmutableNodes.leafNode(desc, descVal))
+ .build();
}
- private static MapEntryNode createDevTypeListEntry(final String typeVal, final String descVal,
- final ListSchemaNode devTypeListSchemaNode) {
-
- final LeafNode<String> typeLeaf = ImmutableNodes.leafNode(type, typeVal);
- final LeafNode<String> descLeaf = ImmutableNodes.leafNode(desc, descVal);
-
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> devTypeMapEntryBldr = Builders
- .mapEntryBuilder(devTypeListSchemaNode);
-
- devTypeMapEntryBldr.addChild(typeLeaf);
- devTypeMapEntryBldr.addChild(descLeaf);
-
- return devTypeMapEntryBldr.build();
- }
-
- private static ContainerNode createChipsContainer(final ContainerSchemaNode container) {
-
- final ListSchemaNode chipsListSchemaNode = (ListSchemaNode) container.getDataChildByName(chip);
-
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> chipsContainerBldr = Builders
- .containerBuilder(container);
-
- final MapNode chipsMap = createChipsList(chipsListSchemaNode);
- chipsContainerBldr.addChild(chipsMap);
-
- return chipsContainerBldr.build();
- }
-
- private static MapNode createChipsList(final ListSchemaNode chipsListSchemaNode) {
-
- final CollectionNodeBuilder<MapEntryNode, MapNode> chipsMapBldr = Builders.mapBuilder(chipsListSchemaNode);
-
- chipsMapBldr.addChild(createChipsListEntry("dev_type_1", "desc1", chipsListSchemaNode));
- chipsMapBldr.addChild(createChipsListEntry("dev_type_2", "desc2", chipsListSchemaNode));
-
- return chipsMapBldr.build();
- }
-
- private static MapEntryNode createChipsListEntry(final String devTypeVal, final String chipDescVal,
- final ListSchemaNode chipsListSchemaNode) {
-
- final LeafNode<String> devTypeLeaf = ImmutableNodes.leafNode(devType, devTypeVal);
- final LeafNode<String> chipDescLeaf = ImmutableNodes.leafNode(chipDesc, chipDescVal);
-
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> chipsMapEntryBldr = Builders
- .mapEntryBuilder(chipsListSchemaNode);
-
- chipsMapEntryBldr.addChild(devTypeLeaf);
- chipsMapEntryBldr.addChild(chipDescLeaf);
-
- return chipsMapEntryBldr.build();
- }
-
- private static ContainerNode createDevicesContainer(final ContainerSchemaNode container) {
-
- final ListSchemaNode devicesListSchemaNode = (ListSchemaNode) container.getDataChildByName(device);
-
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> devicesContainerBldr = Builders
- .containerBuilder(container);
-
- final MapNode devicesMap = createDeviceList(devicesListSchemaNode);
- devicesContainerBldr.addChild(devicesMap);
-
- return devicesContainerBldr.build();
- }
-
- private static MapNode createDeviceList(final ListSchemaNode deviceListSchemaNode) {
-
- final CollectionNodeBuilder<MapEntryNode, MapNode> devicesMapBldr = Builders.mapBuilder(deviceListSchemaNode);
-
- devicesMapBldr.addChild(createDeviceListEntry("dev_type_1", "typedesc1", 123456, "192.168.0.1",
- deviceListSchemaNode));
- devicesMapBldr.addChild(createDeviceListEntry("dev_type_2", "typedesc2", 123457, "192.168.0.1",
- deviceListSchemaNode));
- devicesMapBldr.addChild(createDeviceListEntry("dev_type_2", "typedesc3", 123457, "192.168.0.1",
- deviceListSchemaNode));
- devicesMapBldr.addChild(createDeviceListEntry("dev_type_1", "typedesc2", 123458, "192.168.0.1",
- deviceListSchemaNode));
- devicesMapBldr
- .addChild(createDeviceListEntry("unknown", "unknown", 123457, "192.168.0.1", deviceListSchemaNode));
-
- return devicesMapBldr.build();
+ private static MapEntryNode createChipsListEntry(final String devTypeVal, final String chipDescVal) {
+ return Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(chip, devType, devTypeVal))
+ .addChild(ImmutableNodes.leafNode(devType, devTypeVal))
+ .addChild(ImmutableNodes.leafNode(chipDesc, chipDescVal))
+ .build();
}
private static MapEntryNode createDeviceListEntry(final String typeTextVal, final String descVal, final int snVal,
- final String defaultIpVal, final ListSchemaNode devicesListSchemaNode) {
-
- final LeafNode<String> typeTextLeaf = ImmutableNodes.leafNode(typeText, typeTextVal);
- final LeafNode<String> descLeaf = ImmutableNodes.leafNode(devDesc, descVal);
- final LeafNode<Integer> snValLeaf = ImmutableNodes.leafNode(sn, snVal);
- final LeafNode<String> defaultIpLeaf = ImmutableNodes.leafNode(defaultIp, defaultIpVal);
-
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> devicesMapEntryBldr = Builders
- .mapEntryBuilder(devicesListSchemaNode);
-
- devicesMapEntryBldr.addChild(typeTextLeaf);
- devicesMapEntryBldr.addChild(descLeaf);
- devicesMapEntryBldr.addChild(snValLeaf);
- devicesMapEntryBldr.addChild(defaultIpLeaf);
-
- return devicesMapEntryBldr.build();
+ final String defaultIpVal) {
+ return Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(device, Map.of(typeText, typeTextVal, sn, snVal)))
+ .addChild(ImmutableNodes.leafNode(typeText, typeTextVal))
+ .addChild(ImmutableNodes.leafNode(devDesc, descVal))
+ .addChild(ImmutableNodes.leafNode(sn, snVal))
+ .addChild(ImmutableNodes.leafNode(defaultIp, defaultIpVal))
+ .build();
}
}
Code Review / yangtools.git / blobdiff