BUG-457 Fix TODOs and FIXMEs in yang-data-impl schema package.
[yangtools.git] / yang / yang-data-json / src / test / java / org / opendaylight / yangtools / yang / data / json / schema / TestUtils.java
1 /*
2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.yangtools.yang.data.json.schema;
9
10 import static org.junit.Assert.assertNotNull;
11 import static org.opendaylight.yangtools.yang.data.impl.NodeFactory.createMutableCompositeNode;
12 import static org.opendaylight.yangtools.yang.data.impl.NodeFactory.createMutableSimpleNode;
13
14 import java.io.File;
15 import java.io.FileNotFoundException;
16 import java.net.URI;
17 import java.net.URISyntaxException;
18 import java.text.ParseException;
19 import java.text.SimpleDateFormat;
20 import java.util.ArrayList;
21 import java.util.Collections;
22 import java.util.Date;
23 import java.util.HashMap;
24 import java.util.HashSet;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.Set;
28
29 import org.opendaylight.yangtools.yang.common.QName;
30 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
31 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
32 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
33 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
34 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
35 import org.opendaylight.yangtools.yang.data.api.Node;
36 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
38 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
39 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
40 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
41 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
42 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
43 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
44 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
45 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.Module;
47 import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
48 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
49 import org.slf4j.Logger;
50 import org.slf4j.LoggerFactory;
51
52 public class TestUtils {
53
54     private static final Logger LOG = LoggerFactory.getLogger(TestUtils.class);
55
56     private static final String NAMESPACE_BASE = "simple:container:yang";
57     private static final String NAMESPACE_AUGMENT = "augment:container:yang";
58     private static Date revision_base;
59     private static Date revision_augment;
60
61     static {
62         try {
63             revision_base = new SimpleDateFormat("yyyy-MM-dd").parse("2013-11-12");
64             revision_augment = new SimpleDateFormat("yyyy-MM-dd").parse("2014-03-19");
65         } catch (ParseException e) {
66             e.printStackTrace();
67         }
68     }
69
70     public static Set<Module> loadModules(URI resourceURI) throws FileNotFoundException {
71         final YangModelParser parser = new YangParserImpl();
72         final File testDir = new File(resourceURI);
73         final String[] fileList = testDir.list();
74         final List<File> testFiles = new ArrayList<>();
75         if (fileList == null) {
76             throw new FileNotFoundException(resourceURI.toString());
77         }
78         for (String fileName : fileList) {
79             testFiles.add(new File(testDir, fileName));
80         }
81         return parser.parseYangModels(testFiles);
82     }
83
84     public static Set<Module> loadModulesFrom(String yangPath) throws URISyntaxException {
85         try {
86             return loadModules(TestUtils.class.getResource(yangPath).toURI());
87         } catch (FileNotFoundException e) {
88             LOG.error("Yang files at path: " + yangPath + " weren't loaded.");
89         }
90
91         return null;
92     }
93
94     public static DataSchemaNode resolveDataSchemaNode(String searchedDataSchemaName, Module module) {
95         assertNotNull("Module can't be null", module);
96
97         if (searchedDataSchemaName != null) {
98             for (DataSchemaNode dsn : module.getChildNodes()) {
99                 if (dsn.getQName().getLocalName().equals(searchedDataSchemaName)) {
100                     return dsn;
101                 }
102             }
103         } else if (module.getChildNodes().size() == 1) {
104             return module.getChildNodes().iterator().next();
105         }
106         return null;
107     }
108
109     public static Module resolveModule(String searchedModuleName, Set<Module> modules) {
110         assertNotNull("Modules can't be null.", modules);
111         if (searchedModuleName != null) {
112             for (Module m : modules) {
113                 if (m.getName().equals(searchedModuleName)) {
114                     return m;
115                 }
116             }
117         } else if (modules.size() == 1) {
118             return modules.iterator().next();
119         }
120         return null;
121     }
122
123     /**
124      * Prepare composite node structure according to
125      * /cnsn-to-normalized-node/simple-conainer.json
126      */
127     public static CompositeNode prepareCompositeNodeStruct() {
128         MutableCompositeNode cont = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
129                 "cont"), null, null, null, null);
130
131         // cont1
132         List<Node<?>> contChilds = new ArrayList<>();
133         contChilds.add(createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "cont1"), cont,
134                 Collections.<Node<?>> emptyList(), null, null));
135
136         // cont2
137         MutableCompositeNode cont2 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
138                 "cont2"), cont, null, null, null);
139         List<Node<?>> cont2Childs = new ArrayList<>();
140         cont2Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf21"), cont2,
141                 "value in cont2/lf21", null, null));
142         cont2.setValue(cont2Childs);
143         contChilds.add(cont2);
144
145         // lst1
146         contChilds.add(createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lst1"), cont,
147                 Collections.<Node<?>> emptyList(), null, null));
148
149         // lst2
150         MutableCompositeNode lst2_1 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
151                 "lst2"), cont, null, null, null);
152         List<Node<?>> lst2_1Childs = new ArrayList<>();
153         lst2_1Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf21"), lst2_1,
154                 "some value21", null, null));
155         lst2_1.setValue(lst2_1Childs);
156         contChilds.add(lst2_1);
157
158         MutableCompositeNode lst2_2 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
159                 "lst2"), cont, null, null, null);
160         List<Node<?>> lst2_2Childs = new ArrayList<>();
161         lst2_2Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf22"), lst2_2,
162                 "some value22", null, null));
163         lst2_2.setValue(lst2_2Childs);
164         contChilds.add(lst2_2);
165
166         // lflst1
167         contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lflst1"), cont,
168                 "lflst1_1", null, null));
169         contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lflst1"), cont,
170                 "lflst1_2", null, null));
171
172         // lf1
173         contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf1"), cont,
174                 "lf1", null, null));
175
176         // lf11
177         contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf11"), cont,
178                 "value from case (cs1)", null, null));
179
180         // cont3
181         MutableCompositeNode cont3 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_AUGMENT),
182                 revision_augment, "cont3"), cont, null, null, null);
183         List<Node<?>> cont3Childs = new ArrayList<>();
184         cont3Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_AUGMENT), revision_augment, "lf31"),
185                 cont3, "value in leaf in augment", null, null));
186         cont3.setValue(cont3Childs);
187         contChilds.add(cont3);
188
189         cont.setValue(contChilds);
190         return cont;
191     }
192
193     /**
194      * Prepare composite node structure according to
195      * /cnsn-to-normalized-node/simple-conainer.json
196      */
197     public static ContainerNode prepareNormalizedNodeStruct() throws URISyntaxException {
198         DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders.containerBuilder();
199         containerBuilder.withNodeIdentifier(getNodeIdentifier("cont"));
200         containerBuilder.withChild(Builders.containerBuilder().withNodeIdentifier(getNodeIdentifier("cont1")).build());
201         containerBuilder.withChild(Builders
202                 .containerBuilder()
203                 .withNodeIdentifier(getNodeIdentifier("cont2"))
204                 .withChild(
205                         Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf21"))
206                                 .withValue("value in cont2/lf21").build()).build());
207
208         CollectionNodeBuilder<MapEntryNode, MapNode> lst1 = Builders.mapBuilder().withNodeIdentifier(
209                 getNodeIdentifier("lst1"));
210         lst1.withChild(Builders.mapEntryBuilder()
211                 .withNodeIdentifier(getNodeIdentifierPredicate("lst1", new HashMap<String, Object>()))
212                 .withValue(Collections.<DataContainerChild<? extends PathArgument, ?>> emptyList()).build());
213         containerBuilder.withChild(lst1.build());
214
215         CollectionNodeBuilder<MapEntryNode, MapNode> lst2 = Builders.mapBuilder().withNodeIdentifier(
216                 getNodeIdentifier("lst2"));
217
218         Map<String, Object> lst2_1 = new HashMap<>();
219         lst2_1.put("lf21", "some value21");
220
221         List<DataContainerChild<? extends PathArgument, ?>> lst2_1_values = new ArrayList<>();
222         lst2_1_values.add(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf21"))
223                 .withValue("some value21").build());
224         lst2.withChild(Builders.mapEntryBuilder().withNodeIdentifier(getNodeIdentifierPredicate("lst2", lst2_1))
225                 .withValue(lst2_1_values).build());
226
227         Map<String, Object> lst2_2 = new HashMap<>();
228         lst2_2.put("lf22", "some value22");
229         List<DataContainerChild<? extends PathArgument, ?>> lst2_2_values = new ArrayList<>();
230         lst2_2_values.add(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf22"))
231                 .withValue("some value22").build());
232         lst2.withChild(Builders.mapEntryBuilder().withNodeIdentifier(getNodeIdentifierPredicate("lst2", lst2_2))
233                 .withValue(lst2_2_values).build());
234         containerBuilder.withChild(lst2.build());
235
236         ListNodeBuilder<Object, LeafSetEntryNode<Object>> lflst1 = Builders.leafSetBuilder().withNodeIdentifier(
237                 getNodeIdentifier("lflst1"));
238         lflst1.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(getNodeIdentifier("lflst1", "lflst1_1"))
239                 .withValue("lflst1_1").build());
240         lflst1.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(getNodeIdentifier("lflst1", "lflst1_2"))
241                 .withValue("lflst1_2").build());
242         containerBuilder.withChild(lflst1.build());
243
244         containerBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf1")).withValue("lf1")
245                 .build());
246
247         containerBuilder.withChild(Builders
248                 .choiceBuilder()
249                 .withNodeIdentifier(getNodeIdentifier("chc"))
250                 .withChild(
251                         Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf11"))
252                                 .withValue("value from case (cs1)").build()).build());
253
254         Set<QName> children = new HashSet<>();
255         children.add(new QName(new URI(NAMESPACE_AUGMENT), revision_augment, "cont3"));
256
257         containerBuilder.withChild(Builders
258                 .augmentationBuilder()
259                 .withNodeIdentifier(getAugmentationIdentifier(null, null, null, children))
260                 .withChild(
261                         Builders.containerBuilder()
262                                 .withNodeIdentifier(getNodeIdentifier("cont3", NAMESPACE_AUGMENT, revision_augment))
263                                 .withChild(
264                                         Builders.leafBuilder()
265                                                 .withNodeIdentifier(
266                                                         getNodeIdentifier("lf31", NAMESPACE_AUGMENT, revision_augment))
267                                                 .withValue("value in leaf in augment").build()).build()).build());
268
269         ContainerNode build = containerBuilder.build();
270         return build;
271     }
272
273     private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(String localName) {
274         return new InstanceIdentifier.NodeIdentifier(new QName(URI.create(NAMESPACE_BASE), revision_base, localName));
275     }
276
277     private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(String localName, String namespace, Date revision) {
278         return new InstanceIdentifier.NodeIdentifier(new QName(URI.create(namespace), revision, localName));
279     }
280
281     private static InstanceIdentifier.NodeWithValue getNodeIdentifier(String localName, Object value) {
282         return new InstanceIdentifier.NodeWithValue(new QName(URI.create(NAMESPACE_BASE), revision_base, localName),
283                 value);
284     }
285
286     private static InstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(String localName,
287             Map<String, Object> keys) {
288         Map<QName, Object> predicate = new HashMap<>();
289         for (String key : keys.keySet()) {
290             predicate.put(new QName(URI.create(NAMESPACE_BASE), revision_base, key), keys.get(key));
291         }
292
293         return new InstanceIdentifier.NodeIdentifierWithPredicates(
294
295         new QName(URI.create(NAMESPACE_BASE), revision_base, localName), predicate);
296     }
297
298     private static InstanceIdentifier.AugmentationIdentifier getAugmentationIdentifier(String localName,
299             String namespace, Date revision, Set<QName> children) {
300         return new InstanceIdentifier.AugmentationIdentifier(children);
301     }
302
303 }