*/
package org.opendaylight.controller.sal.restconf.impl.test;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
Object key;
Object data; // List for a CompositeNode, value Object for a SimpleNode
- NodeData( Object key, Object data ) {
+ NodeData(final Object key, final Object data) {
this.key = key;
this.data = data;
}
private static SchemaContext schemaContextModules;
private static SchemaContext schemaContextBehindMountPoint;
+ private static final String RESTCONF_NS = "urn:ietf:params:xml:ns:yang:ietf-restconf";
+
@BeforeClass
public static void init() throws FileNotFoundException {
schemaContextYangsIetf = TestUtils.loadSchemaContext("/full-versions/yangs");
resourceConfig = resourceConfig.registerInstances(restconfImpl, StructuredDataToXmlProvider.INSTANCE,
StructuredDataToJsonProvider.INSTANCE, XmlToCompositeNodeProvider.INSTANCE,
JsonToCompositeNodeProvider.INSTANCE);
- resourceConfig.registerClasses( RestconfDocumentedExceptionMapper.class );
+ resourceConfig.registerClasses(RestconfDocumentedExceptionMapper.class);
return resourceConfig;
}
public void getDataWithUrlMountPoint() throws UnsupportedEncodingException, URISyntaxException {
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
+ any(YangInstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
/**
* MountPoint test. URI represents mount point.
*
- * Slashes in URI behind mount point. lst1 element with key
- * GigabitEthernet0%2F0%2F0%2F0 (GigabitEthernet0/0/0/0) is requested via
- * GET HTTP operation. It is tested whether %2F character is replaced with
- * simple / in InstanceIdentifier parameter in method
- * {@link BrokerFacade#readConfigurationDataBehindMountPoint(MountInstance, InstanceIdentifier)}
- * which is called in method {@link RestconfImpl#readConfigurationData}
+ * Slashes in URI behind mount point. lst1 element with key GigabitEthernet0%2F0%2F0%2F0 (GigabitEthernet0/0/0/0) is
+ * requested via GET HTTP operation. It is tested whether %2F character is replaced with simple / in
+ * InstanceIdentifier parameter in method
+ * {@link BrokerFacade#readConfigurationDataBehindMountPoint(MountInstance, YangInstanceIdentifier)} which is called in
+ * method {@link RestconfImpl#readConfigurationData}
*
*
* @throws ParseException
@Test
public void getDataWithSlashesBehindMountPoint() throws UnsupportedEncodingException, URISyntaxException,
ParseException {
- InstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
+ YangInstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
eq(awaitedInstanceIdentifier))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
assertEquals(200, get(uri, MediaType.APPLICATION_XML));
}
- private InstanceIdentifier prepareInstanceIdentifierForList() throws URISyntaxException, ParseException {
+ private YangInstanceIdentifier prepareInstanceIdentifierForList() throws URISyntaxException, ParseException {
List<PathArgument> parameters = new ArrayList<>();
Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2014-01-09");
QName qNameList = QName.create(uri, revision, "lst1");
QName qNameKeyList = QName.create(uri, revision, "lf11");
- parameters.add(new InstanceIdentifier.NodeIdentifier(qNameCont));
- parameters.add(new InstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
+ parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameCont));
+ parameters.add(new YangInstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
"GigabitEthernet0/0/0/0"));
- return new InstanceIdentifier(parameters);
+ return YangInstanceIdentifier.create(parameters);
}
@Test
public void getDataMountPointIntoHighestElement() throws UnsupportedEncodingException, URISyntaxException {
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
+ any(YangInstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
validateModulesResponseJson(response);
response = target(uri).request("application/yang.api+xml").get();
- validateModulesResponseXml(response);
+ validateModulesResponseXml(response,schemaContextModules);
}
// /streams/
assertTrue(responseBody.contains("streams"));
response = target(uri).request("application/yang.api+xml").get();
- responseBody = response.readEntity(String.class);
- assertNotNull(responseBody);
- assertTrue(responseBody.contains("<streams xmlns=\"urn:ietf:params:xml:ns:yang:ietf-restconf\""));
+ Document responseXmlBody = response.readEntity(Document.class);
+ assertNotNull(responseXmlBody);
+ Element rootNode = responseXmlBody.getDocumentElement();
+
+ assertEquals("streams", rootNode.getLocalName());
+ assertEquals(RESTCONF_NS, rootNode.getNamespaceURI());
}
// /modules/module
Response response = target(uri).request("application/yang.api+xml").get();
assertEquals(200, response.getStatus());
- String responseBody = response.readEntity(String.class);
- assertTrue("Module2 in xml wasn't found", prepareXmlRegex("module2", "2014-01-02", "module:2", responseBody)
- .find());
- String[] split = responseBody.split("<module");
- assertEquals("<module element is returned more then once", 2, split.length);
+ Document responseXml = response.readEntity(Document.class);
+
+
+
+ QName qname = assertedModuleXmlToModuleQName(responseXml.getDocumentElement());
+ assertNotNull(qname);
+
+ assertEquals("module2", qname.getLocalName());
+ assertEquals("module:2", qname.getNamespace().toString());
+ assertEquals("2014-01-02", qname.getFormattedRevision());
response = target(uri).request("application/yang.api+json").get();
assertEquals(200, response.getStatus());
- responseBody = response.readEntity(String.class);
+ String responseBody = response.readEntity(String.class);
assertTrue("Module2 in json wasn't found", prepareJsonRegex("module2", "2014-01-02", "module:2", responseBody)
.find());
- split = responseBody.split("\"module\"");
+ String[] split = responseBody.split("\"module\"");
assertEquals("\"module\" element is returned more then once", 2, split.length);
}
Response response = target(uri).request("application/yang.api+xml").get();
assertEquals(200, response.getStatus());
- String responseBody = response.readEntity(String.class);
- assertTrue("Xml response for /operations dummy-rpc1-module1 is incorrect",
- validateOperationsResponseXml(responseBody, "dummy-rpc1-module1", "module:1").find());
- assertTrue("Xml response for /operations dummy-rpc2-module1 is incorrect",
- validateOperationsResponseXml(responseBody, "dummy-rpc2-module1", "module:1").find());
- assertTrue("Xml response for /operations dummy-rpc1-module2 is incorrect",
- validateOperationsResponseXml(responseBody, "dummy-rpc1-module2", "module:2").find());
- assertTrue("Xml response for /operations dummy-rpc2-module2 is incorrect",
- validateOperationsResponseXml(responseBody, "dummy-rpc2-module2", "module:2").find());
+ Document responseDoc = response.readEntity(Document.class);
+ validateOperationsResponseXml(responseDoc, schemaContextModules);
response = target(uri).request("application/yang.api+json").get();
assertEquals(200, response.getStatus());
- responseBody = response.readEntity(String.class);
+ String responseBody = response.readEntity(String.class);
assertTrue("Json response for /operations dummy-rpc1-module1 is incorrect",
validateOperationsResponseJson(responseBody, "dummy-rpc1-module1", "module1").find());
assertTrue("Json response for /operations dummy-rpc2-module1 is incorrect",
}
+ private void validateOperationsResponseXml(final Document responseDoc, final SchemaContext schemaContext) {
+ Element operationsElem = responseDoc.getDocumentElement();
+ assertEquals(RESTCONF_NS, operationsElem.getNamespaceURI());
+ assertEquals("operations", operationsElem.getLocalName());
+
+
+ HashSet<QName> foundOperations = new HashSet<>();
+
+ NodeList operationsList = operationsElem.getChildNodes();
+ for(int i = 0;i < operationsList.getLength();i++) {
+ org.w3c.dom.Node operation = operationsList.item(i);
+
+ String namespace = operation.getNamespaceURI();
+ String name = operation.getLocalName();
+ QName opQName = QName.create(URI.create(namespace), null, name);
+ foundOperations.add(opQName);
+ }
+
+ for(RpcDefinition schemaOp : schemaContext.getOperations()) {
+ assertTrue(foundOperations.contains(schemaOp.getQName().withoutRevision()));
+ }
+
+ }
+
// /operations/pathToMountPoint/yang-ext:mount
@Test
public void getOperationsBehindMountPointTest() throws FileNotFoundException, UnsupportedEncodingException {
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
Response response = target(uri).request("application/yang.api+xml").get();
assertEquals(200, response.getStatus());
- String responseBody = response.readEntity(String.class);
- assertTrue("Xml response for /operations/mount_point rpc-behind-module1 is incorrect",
- validateOperationsResponseXml(responseBody, "rpc-behind-module1", "module:1:behind:mount:point").find());
- assertTrue("Xml response for /operations/mount_point rpc-behind-module2 is incorrect",
- validateOperationsResponseXml(responseBody, "rpc-behind-module2", "module:2:behind:mount:point").find());
+
+ Document responseDoc = response.readEntity(Document.class);
+ validateOperationsResponseXml(responseDoc, schemaContextBehindMountPoint);
response = target(uri).request("application/yang.api+json").get();
assertEquals(200, response.getStatus());
- responseBody = response.readEntity(String.class);
+ String responseBody = response.readEntity(String.class);
assertTrue("Json response for /operations/mount_point rpc-behind-module1 is incorrect",
validateOperationsResponseJson(responseBody, "rpc-behind-module1", "module1-behind-mount-point").find());
assertTrue("Json response for /operations/mount_point rpc-behind-module2 is incorrect",
}
- private Matcher validateOperationsResponseJson(String searchIn, String rpcName, String moduleName) {
+ private Matcher validateOperationsResponseJson(final String searchIn, final String rpcName, final String moduleName) {
StringBuilder regex = new StringBuilder();
regex.append("^");
}
- private Matcher validateOperationsResponseXml(String searchIn, String rpcName, String namespace) {
+ private Matcher validateOperationsResponseXml(final String searchIn, final String rpcName, final String namespace) {
StringBuilder regex = new StringBuilder();
regex.append("^");
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
response = target(uri).request("application/yang.api+xml").get();
assertEquals(200, response.getStatus());
- responseBody = response.readEntity(String.class);
- assertTrue(
- "module1-behind-mount-point in json wasn't found",
- prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
- .find());
- assertTrue(
- "module2-behind-mount-point in json wasn't found",
- prepareXmlRegex("module2-behind-mount-point", "2014-02-04", "module:2:behind:mount:point", responseBody)
- .find());
+ validateModulesResponseXml(response, schemaContextBehindMountPoint);
}
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
response = target(uri).request("application/yang.api+xml").get();
assertEquals(200, response.getStatus());
- responseBody = response.readEntity(String.class);
- assertTrue(
- "module1-behind-mount-point in json wasn't found",
- prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
- .find());
- split = responseBody.split("<module");
- assertEquals("<module element is returned more then once", 2, split.length);
+ Document responseXml = response.readEntity(Document.class);
+
+ QName module = assertedModuleXmlToModuleQName(responseXml.getDocumentElement());
+
+ assertEquals("module1-behind-mount-point", module.getLocalName());
+ assertEquals("2014-02-03", module.getFormattedRevision());
+ assertEquals("module:1:behind:mount:point", module.getNamespace().toString());
+
}
- private void validateModulesResponseXml(Response response) {
+ private void validateModulesResponseXml(final Response response, final SchemaContext schemaContext) {
assertEquals(200, response.getStatus());
- String responseBody = response.readEntity(String.class);
+ Document responseBody = response.readEntity(Document.class);
+ NodeList moduleNodes = responseBody.getDocumentElement().getElementsByTagNameNS(RESTCONF_NS, "module");
- assertTrue("Module1 in xml wasn't found", prepareXmlRegex("module1", "2014-01-01", "module:1", responseBody)
- .find());
- assertTrue("Module2 in xml wasn't found", prepareXmlRegex("module2", "2014-01-02", "module:2", responseBody)
- .find());
- assertTrue("Module3 in xml wasn't found", prepareXmlRegex("module3", "2014-01-03", "module:3", responseBody)
- .find());
+ assertTrue(moduleNodes.getLength() > 0);
+
+ HashSet<QName> foundModules = new HashSet<>();
+
+ for(int i=0;i < moduleNodes.getLength();i++) {
+ org.w3c.dom.Node module = moduleNodes.item(i);
+
+ QName name = assertedModuleXmlToModuleQName(module);
+ foundModules.add(name);
+ }
+
+ assertAllModules(foundModules,schemaContext);
+ }
+
+ private void assertAllModules(final Set<QName> foundModules, final SchemaContext schemaContext) {
+ for(Module module : schemaContext.getModules()) {
+ QName current = QName.create(module.getQNameModule(),module.getName());
+ assertTrue("Module not found in response.",foundModules.contains(current));
+ }
+
+ }
+
+ private QName assertedModuleXmlToModuleQName(final org.w3c.dom.Node module) {
+ assertEquals("module", module.getLocalName());
+ assertEquals(RESTCONF_NS, module.getNamespaceURI());
+ String revision = null;
+ String namespace = null;
+ String name = null;
+
+
+ NodeList childNodes = module.getChildNodes();
+
+ for(int i =0;i < childNodes.getLength(); i++) {
+ org.w3c.dom.Node child = childNodes.item(i);
+ assertEquals(RESTCONF_NS, child.getNamespaceURI());
+
+ switch(child.getLocalName()) {
+ case "name":
+ assertNull("Name element appeared multiple times",name);
+ name = child.getTextContent().trim();
+ break;
+ case "revision":
+ assertNull("Revision element appeared multiple times",revision);
+ revision = child.getTextContent().trim();
+ break;
+
+ case "namespace":
+ assertNull("Namespace element appeared multiple times",namespace);
+ namespace = child.getTextContent().trim();
+ break;
+ }
+ }
+
+ assertNotNull("Revision was not part of xml",revision);
+ assertNotNull("Module namespace was not part of xml",namespace);
+ assertNotNull("Module identiffier was not part of xml",name);
+
+
+ // TODO Auto-generated method stub
+
+ return QName.create(namespace,revision,name);
}
- private void validateModulesResponseJson(Response response) {
+ private void validateModulesResponseJson(final Response response) {
assertEquals(200, response.getStatus());
String responseBody = response.readEntity(String.class);
.find());
}
- private Matcher prepareJsonRegex(String module, String revision, String namespace, String searchIn) {
+ private Matcher prepareJsonRegex(final String module, final String revision, final String namespace,
+ final String searchIn) {
StringBuilder regex = new StringBuilder();
regex.append("^");
}
- private Matcher prepareXmlRegex(String module, String revision, String namespace, String searchIn) {
- StringBuilder regex = new StringBuilder();
- regex.append("^");
-
- regex.append(".*<module.*");
- regex.append(".*>");
-
- regex.append(".*<name>");
- regex.append(".*" + module);
- regex.append(".*<\\/name>");
-
- regex.append(".*<revision>");
- regex.append(".*" + revision);
- regex.append(".*<\\/revision>");
-
- regex.append(".*<namespace>");
- regex.append(".*" + namespace);
- regex.append(".*<\\/namespace>");
- regex.append(".*<\\/module.*>");
-
- regex.append(".*");
- regex.append("$");
-
- Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
- return ptrn.matcher(searchIn);
- }
-
- private void prepareMockForModulesTest(ControllerContext mockedControllerContext) throws FileNotFoundException {
+ private void prepareMockForModulesTest(final ControllerContext mockedControllerContext)
+ throws FileNotFoundException {
SchemaContext schemaContext = TestUtils.loadSchemaContext("/modules");
mockedControllerContext.setGlobalSchema(schemaContext);
// when(mockedControllerContext.getGlobalSchema()).thenReturn(schemaContext);
}
- private int get(String uri, String mediaType) {
+ private int get(final String uri, final String mediaType) {
return target(uri).request(mediaType).get().getStatus();
}
}
private void mockReadOperationalDataMethod() {
- when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
+ when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
}
private void mockReadConfigurationDataMethod() {
- when(brokerFacade.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
+ when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
}
private static CompositeNode prepareCompositeNodeWithIetfInterfacesInterfacesData() {
return null;
}
+ /**
+ * If includeWhiteChars URI parameter is set to false then no white characters can be included in returned output
+ *
+ * @throws UnsupportedEncodingException
+ */
+ @Test
+ public void getDataWithUriIncludeWhiteCharsParameterTest() throws UnsupportedEncodingException {
+ getDataWithUriIncludeWhiteCharsParameter("config");
+ getDataWithUriIncludeWhiteCharsParameter("operational");
+ }
+
+ private void getDataWithUriIncludeWhiteCharsParameter(final String target) throws UnsupportedEncodingException {
+ mockReadConfigurationDataMethod();
+ String uri = "/" + target + "/ietf-interfaces:interfaces/interface/eth0";
+ Response response = target(uri).queryParam("prettyPrint", "false").request("application/xml").get();
+ String xmlData = response.readEntity(String.class);
+
+ Pattern pattern = Pattern.compile(".*(>\\s+|\\s+<).*", Pattern.DOTALL);
+ Matcher matcher = pattern.matcher(xmlData);
+ // XML element can't surrounded with white character (e.g "> " or
+ // " <")
+ assertFalse(matcher.matches());
+
+ response = target(uri).queryParam("prettyPrint", "false").request("application/json").get();
+ String jsonData = response.readEntity(String.class);
+ pattern = Pattern.compile(".*(\\}\\s+|\\s+\\{|\\]\\s+|\\s+\\[|\\s+:|:\\s+).*", Pattern.DOTALL);
+ matcher = pattern.matcher(jsonData);
+ // JSON element can't surrounded with white character (e.g "} ", " {",
+ // "] ", " [", " :" or ": ")
+ assertFalse(matcher.matches());
+ }
+
@Test
public void getDataWithUriDepthParameterTest() throws UnsupportedEncodingException {
- ControllerContext.getInstance().setGlobalSchema( schemaContextModules );
-
- CompositeNode depth1Cont = toCompositeNode(
- toCompositeNodeData( toNestedQName( "depth1-cont" ),
- toCompositeNodeData( toNestedQName( "depth2-cont1" ),
- toCompositeNodeData( toNestedQName( "depth3-cont1" ),
- toCompositeNodeData( toNestedQName( "depth4-cont1" ),
- toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
- ),
- toCompositeNodeData( toNestedQName( "depth2-cont2" ),
- toCompositeNodeData( toNestedQName( "depth3-cont2" ),
- toCompositeNodeData( toNestedQName( "depth4-cont2" ),
- toSimpleNodeData( toNestedQName( "depth5-leaf2" ), "depth5-leaf2-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth4-leaf2" ), "depth4-leaf2-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth3-leaf2" ), "depth3-leaf2-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth2-leaf1" ), "depth2-leaf1-value" )
- ) );
-
- when( brokerFacade.readConfigurationData( any( InstanceIdentifier.class ) ) )
- .thenReturn( depth1Cont );
+ ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
+
+ CompositeNode depth1Cont = toCompositeNode(toCompositeNodeData(
+ toNestedQName("depth1-cont"),
+ toCompositeNodeData(
+ toNestedQName("depth2-cont1"),
+ toCompositeNodeData(
+ toNestedQName("depth3-cont1"),
+ toCompositeNodeData(toNestedQName("depth4-cont1"),
+ toSimpleNodeData(toNestedQName("depth5-leaf1"), "depth5-leaf1-value")),
+ toSimpleNodeData(toNestedQName("depth4-leaf1"), "depth4-leaf1-value")),
+ toSimpleNodeData(toNestedQName("depth3-leaf1"), "depth3-leaf1-value")),
+ toCompositeNodeData(
+ toNestedQName("depth2-cont2"),
+ toCompositeNodeData(
+ toNestedQName("depth3-cont2"),
+ toCompositeNodeData(toNestedQName("depth4-cont2"),
+ toSimpleNodeData(toNestedQName("depth5-leaf2"), "depth5-leaf2-value")),
+ toSimpleNodeData(toNestedQName("depth4-leaf2"), "depth4-leaf2-value")),
+ toSimpleNodeData(toNestedQName("depth3-leaf2"), "depth3-leaf2-value")),
+ toSimpleNodeData(toNestedQName("depth2-leaf1"), "depth2-leaf1-value")));
+
+ when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(depth1Cont);
// Test config with depth 1
- Response response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "1" )
- .request( "application/xml" ).get();
+ Response response = target("/config/nested-module:depth1-cont").queryParam("depth", "1")
+ .request("application/xml").get();
- verifyXMLResponse( response, expectEmptyContainer( "depth1-cont" ) );
+ verifyXMLResponse(response, expectEmptyContainer("depth1-cont"));
// Test config with depth 2
- response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "2" )
- .request( "application/xml" ).get();
+ response = target("/config/nested-module:depth1-cont").queryParam("depth", "2").request("application/xml")
+ .get();
-// String xml="<depth1-cont><depth2-cont1/><depth2-cont2/><depth2-leaf1>depth2-leaf1-value</depth2-leaf1></depth1-cont>";
-// Response mr=mock(Response.class);
-// when(mr.getEntity()).thenReturn( new java.io.StringBufferInputStream(xml) );
+ // String
+ // xml="<depth1-cont><depth2-cont1/><depth2-cont2/><depth2-leaf1>depth2-leaf1-value</depth2-leaf1></depth1-cont>";
+ // Response mr=mock(Response.class);
+ // when(mr.getEntity()).thenReturn( new
+ // java.io.StringBufferInputStream(xml) );
- verifyXMLResponse( response,
- expectContainer( "depth1-cont",
- expectEmptyContainer( "depth2-cont1" ),
- expectEmptyContainer( "depth2-cont2" ),
- expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
- ) );
+ verifyXMLResponse(
+ response,
+ expectContainer("depth1-cont", expectEmptyContainer("depth2-cont1"),
+ expectEmptyContainer("depth2-cont2"), expectLeaf("depth2-leaf1", "depth2-leaf1-value")));
// Test config with depth 3
- response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "3" )
- .request( "application/xml" ).get();
-
- verifyXMLResponse( response,
- expectContainer( "depth1-cont",
- expectContainer( "depth2-cont1",
- expectEmptyContainer( "depth3-cont1" ),
- expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
- ),
- expectContainer( "depth2-cont2",
- expectEmptyContainer( "depth3-cont2" ),
- expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
- ),
- expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
- ) );
+ response = target("/config/nested-module:depth1-cont").queryParam("depth", "3").request("application/xml")
+ .get();
+
+ verifyXMLResponse(
+ response,
+ expectContainer(
+ "depth1-cont",
+ expectContainer("depth2-cont1", expectEmptyContainer("depth3-cont1"),
+ expectLeaf("depth3-leaf1", "depth3-leaf1-value")),
+ expectContainer("depth2-cont2", expectEmptyContainer("depth3-cont2"),
+ expectLeaf("depth3-leaf2", "depth3-leaf2-value")),
+ expectLeaf("depth2-leaf1", "depth2-leaf1-value")));
// Test config with depth 4
- response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "4" )
- .request( "application/xml" ).get();
-
- verifyXMLResponse( response,
- expectContainer( "depth1-cont",
- expectContainer( "depth2-cont1",
- expectContainer( "depth3-cont1",
- expectEmptyContainer( "depth4-cont1" ),
- expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
- ),
- expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
- ),
- expectContainer( "depth2-cont2",
- expectContainer( "depth3-cont2",
- expectEmptyContainer( "depth4-cont2" ),
- expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
- ),
- expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
- ),
- expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
- ) );
+ response = target("/config/nested-module:depth1-cont").queryParam("depth", "4").request("application/xml")
+ .get();
+
+ verifyXMLResponse(
+ response,
+ expectContainer(
+ "depth1-cont",
+ expectContainer(
+ "depth2-cont1",
+ expectContainer("depth3-cont1", expectEmptyContainer("depth4-cont1"),
+ expectLeaf("depth4-leaf1", "depth4-leaf1-value")),
+ expectLeaf("depth3-leaf1", "depth3-leaf1-value")),
+ expectContainer(
+ "depth2-cont2",
+ expectContainer("depth3-cont2", expectEmptyContainer("depth4-cont2"),
+ expectLeaf("depth4-leaf2", "depth4-leaf2-value")),
+ expectLeaf("depth3-leaf2", "depth3-leaf2-value")),
+ expectLeaf("depth2-leaf1", "depth2-leaf1-value")));
// Test config with depth 5
- response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "5" )
- .request( "application/xml" ).get();
-
- verifyXMLResponse( response,
- expectContainer( "depth1-cont",
- expectContainer( "depth2-cont1",
- expectContainer( "depth3-cont1",
- expectContainer( "depth4-cont1",
- expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
- ),
- expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
- ),
- expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
- ),
- expectContainer( "depth2-cont2",
- expectContainer( "depth3-cont2",
- expectContainer( "depth4-cont2",
- expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
- ),
- expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
- ),
- expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
- ),
- expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
- ) );
+ response = target("/config/nested-module:depth1-cont").queryParam("depth", "5").request("application/xml")
+ .get();
+
+ verifyXMLResponse(
+ response,
+ expectContainer(
+ "depth1-cont",
+ expectContainer(
+ "depth2-cont1",
+ expectContainer(
+ "depth3-cont1",
+ expectContainer("depth4-cont1",
+ expectLeaf("depth5-leaf1", "depth5-leaf1-value")),
+ expectLeaf("depth4-leaf1", "depth4-leaf1-value")),
+ expectLeaf("depth3-leaf1", "depth3-leaf1-value")),
+ expectContainer(
+ "depth2-cont2",
+ expectContainer(
+ "depth3-cont2",
+ expectContainer("depth4-cont2",
+ expectLeaf("depth5-leaf2", "depth5-leaf2-value")),
+ expectLeaf("depth4-leaf2", "depth4-leaf2-value")),
+ expectLeaf("depth3-leaf2", "depth3-leaf2-value")),
+ expectLeaf("depth2-leaf1", "depth2-leaf1-value")));
// Test config with depth unbounded
- response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "unbounded" )
- .request( "application/xml" ).get();
-
- verifyXMLResponse( response,
- expectContainer( "depth1-cont",
- expectContainer( "depth2-cont1",
- expectContainer( "depth3-cont1",
- expectContainer( "depth4-cont1",
- expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
- ),
- expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
- ),
- expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
- ),
- expectContainer( "depth2-cont2",
- expectContainer( "depth3-cont2",
- expectContainer( "depth4-cont2",
- expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
- ),
- expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
- ),
- expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
- ),
- expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
- ) );
+ response = target("/config/nested-module:depth1-cont").queryParam("depth", "unbounded")
+ .request("application/xml").get();
+
+ verifyXMLResponse(
+ response,
+ expectContainer(
+ "depth1-cont",
+ expectContainer(
+ "depth2-cont1",
+ expectContainer(
+ "depth3-cont1",
+ expectContainer("depth4-cont1",
+ expectLeaf("depth5-leaf1", "depth5-leaf1-value")),
+ expectLeaf("depth4-leaf1", "depth4-leaf1-value")),
+ expectLeaf("depth3-leaf1", "depth3-leaf1-value")),
+ expectContainer(
+ "depth2-cont2",
+ expectContainer(
+ "depth3-cont2",
+ expectContainer("depth4-cont2",
+ expectLeaf("depth5-leaf2", "depth5-leaf2-value")),
+ expectLeaf("depth4-leaf2", "depth4-leaf2-value")),
+ expectLeaf("depth3-leaf2", "depth3-leaf2-value")),
+ expectLeaf("depth2-leaf1", "depth2-leaf1-value")));
// Test operational
- CompositeNode depth2Cont1 = toCompositeNode(
- toCompositeNodeData( toNestedQName( "depth2-cont1" ),
- toCompositeNodeData( toNestedQName( "depth3-cont1" ),
- toCompositeNodeData( toNestedQName( "depth4-cont1" ),
- toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
- ),
- toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
- ) );
-
- when( brokerFacade.readOperationalData( any( InstanceIdentifier.class ) ) )
- .thenReturn( depth2Cont1 );
-
- response = target( "/operational/nested-module:depth1-cont/depth2-cont1" )
- .queryParam( "depth", "3" ).request( "application/xml" ).get();
-
- verifyXMLResponse( response,
- expectContainer( "depth2-cont1",
- expectContainer( "depth3-cont1",
- expectEmptyContainer( "depth4-cont1" ),
- expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
- ),
- expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
- ) );
+ CompositeNode depth2Cont1 = toCompositeNode(toCompositeNodeData(
+ toNestedQName("depth2-cont1"),
+ toCompositeNodeData(
+ toNestedQName("depth3-cont1"),
+ toCompositeNodeData(toNestedQName("depth4-cont1"),
+ toSimpleNodeData(toNestedQName("depth5-leaf1"), "depth5-leaf1-value")),
+ toSimpleNodeData(toNestedQName("depth4-leaf1"), "depth4-leaf1-value")),
+ toSimpleNodeData(toNestedQName("depth3-leaf1"), "depth3-leaf1-value")));
+
+ when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(depth2Cont1);
+
+ response = target("/operational/nested-module:depth1-cont/depth2-cont1").queryParam("depth", "3")
+ .request("application/xml").get();
+
+ verifyXMLResponse(
+ response,
+ expectContainer(
+ "depth2-cont1",
+ expectContainer("depth3-cont1", expectEmptyContainer("depth4-cont1"),
+ expectLeaf("depth4-leaf1", "depth4-leaf1-value")),
+ expectLeaf("depth3-leaf1", "depth3-leaf1-value")));
}
@Test
public void getDataWithInvalidDepthParameterTest() {
- ControllerContext.getInstance().setGlobalSchema( schemaContextModules );
+ ControllerContext.getInstance().setGlobalSchema(schemaContextModules);
- final MultivaluedMap<String,String> paramMap = new MultivaluedHashMap<>();
- paramMap.putSingle( "depth", "1o" );
- UriInfo mockInfo = mock( UriInfo.class );
- when( mockInfo.getQueryParameters( false ) ).thenAnswer(
- new Answer<MultivaluedMap<String,String>>() {
- @Override
- public MultivaluedMap<String, String> answer( InvocationOnMock invocation ) {
- return paramMap;
- }
- } );
+ final MultivaluedMap<String, String> paramMap = new MultivaluedHashMap<>();
+ paramMap.putSingle("depth", "1o");
+ UriInfo mockInfo = mock(UriInfo.class);
+ when(mockInfo.getQueryParameters(false)).thenAnswer(new Answer<MultivaluedMap<String, String>>() {
+ @Override
+ public MultivaluedMap<String, String> answer(final InvocationOnMock invocation) {
+ return paramMap;
+ }
+ });
- getDataWithInvalidDepthParameterTest( mockInfo );
+ getDataWithInvalidDepthParameterTest(mockInfo);
- paramMap.putSingle( "depth", "0" );
- getDataWithInvalidDepthParameterTest( mockInfo );
+ paramMap.putSingle("depth", "0");
+ getDataWithInvalidDepthParameterTest(mockInfo);
- paramMap.putSingle( "depth", "-1" );
- getDataWithInvalidDepthParameterTest( mockInfo );
+ paramMap.putSingle("depth", "-1");
+ getDataWithInvalidDepthParameterTest(mockInfo);
}
- private void getDataWithInvalidDepthParameterTest( UriInfo uriInfo ) {
+ private void getDataWithInvalidDepthParameterTest(final UriInfo uriInfo) {
try {
- restconfImpl.readConfigurationData( "nested-module:depth1-cont", uriInfo );
- fail( "Expected RestconfDocumentedException" );
- }
- catch( RestconfDocumentedException e ) {
- assertTrue( "Unexpected error message: " + e.getErrors().get( 0 ).getErrorMessage(),
- e.getErrors().get( 0 ).getErrorMessage().contains( "depth" ) );
+ restconfImpl.readConfigurationData("nested-module:depth1-cont", uriInfo);
+ fail("Expected RestconfDocumentedException");
+ } catch (RestconfDocumentedException e) {
+ assertTrue("Unexpected error message: " + e.getErrors().get(0).getErrorMessage(), e.getErrors().get(0)
+ .getErrorMessage().contains("depth"));
}
}
- private void verifyXMLResponse( Response response, NodeData nodeData ) {
+ private void verifyXMLResponse(final Response response, final NodeData nodeData) {
- Document doc = TestUtils.loadDocumentFrom( (InputStream) response.getEntity() );
- assertNotNull( "Could not parse XML document", doc );
+ Document doc = TestUtils.loadDocumentFrom((InputStream) response.getEntity());
+ assertNotNull("Could not parse XML document", doc);
- //System.out.println(TestUtils.getDocumentInPrintableForm( doc ));
+ // System.out.println(TestUtils.getDocumentInPrintableForm( doc ));
- verifyContainerElement( doc.getDocumentElement(), nodeData );
+ verifyContainerElement(doc.getDocumentElement(), nodeData);
}
@SuppressWarnings("unchecked")
- private void verifyContainerElement( Element element, NodeData nodeData ) {
+ private void verifyContainerElement(final Element element, final NodeData nodeData) {
- assertEquals( "Element local name", nodeData.key, element.getNodeName() );
+ assertEquals("Element local name", nodeData.key, element.getNodeName());
NodeList childNodes = element.getChildNodes();
- if( nodeData.data == null ) { // empty container
- assertTrue( "Expected no child elements for \"" + element.getNodeName() + "\"",
- childNodes.getLength() == 0 );
+ if (nodeData.data == null) { // empty container
+ assertTrue("Expected no child elements for \"" + element.getNodeName() + "\"", childNodes.getLength() == 0);
return;
}
- Map<String,NodeData> expChildMap = Maps.newHashMap();
- for( NodeData expChild: (List<NodeData>)nodeData.data ) {
- expChildMap.put( expChild.key.toString(), expChild );
+ Map<String, NodeData> expChildMap = Maps.newHashMap();
+ for (NodeData expChild : (List<NodeData>) nodeData.data) {
+ expChildMap.put(expChild.key.toString(), expChild);
}
- for( int i = 0; i < childNodes.getLength(); i++ ) {
- org.w3c.dom.Node actualChild = childNodes.item( i );
- if( !( actualChild instanceof Element ) ) {
+ for (int i = 0; i < childNodes.getLength(); i++) {
+ org.w3c.dom.Node actualChild = childNodes.item(i);
+ if (!(actualChild instanceof Element)) {
continue;
}
- Element actualElement = (Element)actualChild;
- NodeData expChild = expChildMap.remove( actualElement.getNodeName() );
- assertNotNull( "Unexpected child element for parent \"" + element.getNodeName() +
- "\": " + actualElement.getNodeName(), expChild );
-
- if( expChild.data == null || expChild.data instanceof List ) {
- verifyContainerElement( actualElement, expChild );
- }
- else {
- assertEquals( "Text content for element: " + actualElement.getNodeName(),
- expChild.data, actualElement.getTextContent() );
+ Element actualElement = (Element) actualChild;
+ NodeData expChild = expChildMap.remove(actualElement.getNodeName());
+ assertNotNull(
+ "Unexpected child element for parent \"" + element.getNodeName() + "\": "
+ + actualElement.getNodeName(), expChild);
+
+ if (expChild.data == null || expChild.data instanceof List) {
+ verifyContainerElement(actualElement, expChild);
+ } else {
+ assertEquals("Text content for element: " + actualElement.getNodeName(), expChild.data,
+ actualElement.getTextContent());
}
}
- if( !expChildMap.isEmpty() ) {
- fail( "Missing elements for parent \"" + element.getNodeName() +
- "\": " + expChildMap.keySet() );
+ if (!expChildMap.isEmpty()) {
+ fail("Missing elements for parent \"" + element.getNodeName() + "\": " + expChildMap.keySet());
}
}
- private NodeData expectContainer( String name, NodeData... childData ) {
- return new NodeData( name, Lists.newArrayList( childData ) );
+ private NodeData expectContainer(final String name, final NodeData... childData) {
+ return new NodeData(name, Lists.newArrayList(childData));
}
- private NodeData expectEmptyContainer( String name ) {
- return new NodeData( name, null );
+ private NodeData expectEmptyContainer(final String name) {
+ return new NodeData(name, null);
}
- private NodeData expectLeaf( String name, Object value ) {
- return new NodeData( name, value );
+ private NodeData expectLeaf(final String name, final Object value) {
+ return new NodeData(name, value);
}
- private QName toNestedQName( String localName ) {
- return QName.create( "urn:nested:module", "2014-06-3", localName );
+ private QName toNestedQName(final String localName) {
+ return QName.create("urn:nested:module", "2014-06-3", localName);
}
@SuppressWarnings("unchecked")
- private CompositeNode toCompositeNode( NodeData nodeData ) {
+ private CompositeNode toCompositeNode(final NodeData nodeData) {
CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
- builder.setQName( (QName) nodeData.key );
+ builder.setQName((QName) nodeData.key);
- for( NodeData child: (List<NodeData>)nodeData.data ) {
- if( child.data instanceof List ) {
- builder.add( toCompositeNode( child ) );
- }
- else {
- builder.addLeaf( (QName) child.key, child.data );
+ for (NodeData child : (List<NodeData>) nodeData.data) {
+ if (child.data instanceof List) {
+ builder.add(toCompositeNode(child));
+ } else {
+ builder.addLeaf((QName) child.key, child.data);
}
}
return builder.toInstance();
}
- private NodeData toCompositeNodeData( QName key, NodeData... childData ) {
- return new NodeData( key, Lists.newArrayList( childData ) );
+ private NodeData toCompositeNodeData(final QName key, final NodeData... childData) {
+ return new NodeData(key, Lists.newArrayList(childData));
}
- private NodeData toSimpleNodeData( QName key, Object value ) {
- return new NodeData( key, value );
+ private NodeData toSimpleNodeData(final QName key, final Object value) {
+ return new NodeData(key, value);
}
}
Code Review / controller.git / blobdiff