opendaylight/md-sal/sal-clustering-commons/src/test/java/org/opendaylight/controller/cluster/datastore/node/utils/serialization/PathArgumentSerializerTest.java

   1 /*
   2  * Copyright (c) 2014, 2015 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
   9 package org.opendaylight.controller.cluster.datastore.node.utils.serialization;
  10
  11 import com.google.common.collect.ImmutableMap;
  12 import com.google.common.collect.ImmutableSet;
  13 import org.junit.Rule;
  14 import org.junit.Test;
  15 import org.junit.rules.ExpectedException;
  16 import org.opendaylight.controller.cluster.datastore.util.TestModel;
  17 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  20
  21 import java.net.URI;
  22 import java.util.Date;
  23 import java.util.HashMap;
  24 import java.util.Map;
  25
  26 import static org.junit.Assert.assertEquals;
  27 import static org.mockito.Matchers.any;
  28 import static org.mockito.Matchers.anyString;
  29 import static org.mockito.Mockito.mock;
  30 import static org.mockito.Mockito.when;
  31
  32 public class PathArgumentSerializerTest{
  33
  34     @Rule
  35     public ExpectedException expectedException = ExpectedException.none();
  36
  37     @Test
  38     public void testSerializeNullContext(){
  39         expectedException.expect(NullPointerException.class);
  40         expectedException.expectMessage("context should not be null");
  41
  42         PathArgumentSerializer.serialize(null, mock(
  43             YangInstanceIdentifier.PathArgument.class));
  44     }
  45
  46     @Test
  47     public void testSerializeNullPathArgument(){
  48         expectedException.expect(NullPointerException.class);
  49         expectedException.expectMessage("pathArgument should not be null");
  50
  51         PathArgumentSerializer.serialize(mock(QNameSerializationContext.class), null);
  52
  53     }
  54
  55     @Test
  56     public void testDeSerializeNullContext(){
  57         expectedException.expect(NullPointerException.class);
  58         expectedException.expectMessage("context should not be null");
  59
  60         PathArgumentSerializer.deSerialize(null, NormalizedNodeMessages.PathArgument.getDefaultInstance());
  61
  62     }
  63
  64     @Test
  65     public void testDeSerializeNullPathArgument(){
  66         expectedException.expect(NullPointerException.class);
  67         expectedException.expectMessage("pathArgument should not be null");
  68
  69         PathArgumentSerializer.deSerialize(mock(QNameDeSerializationContext.class), null);
  70
  71     }
  72
  73     @Test
  74     public void testSerializeNodeIdentifier(){
  75         QNameSerializationContext serializationContext = mock(QNameSerializationContext.class);
  76
  77         when(serializationContext.addLocalName(anyString())).thenReturn(5);
  78         when(serializationContext.addNamespace(any(URI.class))).thenReturn(10);
  79         when(serializationContext.addRevision(any(Date.class))).thenReturn(11);
  80
  81         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
  82             .serialize(serializationContext,
  83                 new YangInstanceIdentifier.NodeIdentifier(
  84                     TestModel.TEST_QNAME));
  85
  86         assertEquals(PathArgumentType.NODE_IDENTIFIER.ordinal(), actual.getIntType());
  87         assertEquals(5, actual.getNodeType().getLocalName());
  88         assertEquals(10, actual.getNodeType().getNamespace());
  89         assertEquals(11, actual.getNodeType().getRevision());
  90
  91
  92     }
  93
  94     @Test
  95     public void testSerializeNodeIdentifierWithValue(){
  96         QNameSerializationContext serializationContext = mock(QNameSerializationContext.class);
  97
  98         when(serializationContext.addLocalName(anyString())).thenReturn(5);
  99         when(serializationContext.addNamespace(any(URI.class))).thenReturn(10);
 100         when(serializationContext.addRevision(any(Date.class))).thenReturn(11);
 101
 102         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
 103             .serialize(serializationContext,
 104                 new YangInstanceIdentifier.NodeWithValue(
 105                     TestModel.TEST_QNAME, "foo"));
 106
 107         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal(), actual.getIntType());
 108         assertEquals(5, actual.getNodeType().getLocalName());
 109         assertEquals(10, actual.getNodeType().getNamespace());
 110         assertEquals(11, actual.getNodeType().getRevision());
 111         assertEquals("foo", actual.getAttribute(0).getValue());
 112
 113
 114     }
 115
 116     @Test
 117     public void testSerializeNodeIdentifierWithPredicates(){
 118         QNameSerializationContext serializationContext = mock(QNameSerializationContext.class);
 119
 120         when(serializationContext.addLocalName("test")).thenReturn(5);
 121         when(serializationContext.addLocalName("child-name")).thenReturn(55);
 122
 123         when(serializationContext.addNamespace(TestModel.TEST_QNAME.getNamespace())).thenReturn(
 124             10);
 125         when(serializationContext.addNamespace(TestModel.CHILD_NAME_QNAME.getNamespace())).thenReturn(66);
 126
 127         when(serializationContext.addRevision(TestModel.TEST_QNAME.getRevision())).thenReturn(
 128             11);
 129         when(serializationContext.addRevision(TestModel.CHILD_NAME_QNAME.getRevision())).thenReturn(77);
 130
 131         Map<QName, Object> predicates = new HashMap<>();
 132
 133         predicates.put(TestModel.CHILD_NAME_QNAME, "foobar");
 134
 135         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
 136             .serialize(serializationContext,
 137                 new YangInstanceIdentifier.NodeIdentifierWithPredicates(
 138                     TestModel.TEST_QNAME, predicates));
 139
 140         assertEquals(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal(), actual.getIntType());
 141         assertEquals(5, actual.getNodeType().getLocalName());
 142         assertEquals(10, actual.getNodeType().getNamespace());
 143         assertEquals(11, actual.getNodeType().getRevision());
 144
 145         assertEquals(55, actual.getAttribute(0).getName().getLocalName());
 146         assertEquals(66, actual.getAttribute(0).getName().getNamespace());
 147         assertEquals(77, actual.getAttribute(0).getName().getRevision());
 148
 149         assertEquals("foobar", actual.getAttribute(0).getValue());
 150
 151
 152     }
 153
 154     @Test
 155     public void testSerializeAugmentationIdentifier(){
 156         QNameSerializationContext serializationContext = mock(QNameSerializationContext.class);
 157
 158         when(serializationContext.addLocalName(anyString())).thenReturn(55);
 159         when(serializationContext.addNamespace(any(URI.class))).thenReturn(66);
 160         when(serializationContext.addRevision(any(Date.class))).thenReturn(77);
 161
 162         NormalizedNodeMessages.PathArgument actual = PathArgumentSerializer
 163             .serialize(serializationContext,
 164                 new YangInstanceIdentifier.AugmentationIdentifier(
 165                     ImmutableSet.of(TestModel.TEST_QNAME)));
 166
 167         assertEquals(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal(), actual.getIntType());
 168
 169         assertEquals(55, actual.getAttribute(0).getName().getLocalName());
 170         assertEquals(66, actual.getAttribute(0).getName().getNamespace());
 171         assertEquals(77, actual.getAttribute(0).getName().getRevision());
 172
 173     }
 174
 175     @Test
 176     public void testDeSerializeNodeIdentifier(){
 177
 178         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 179         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 180         NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
 181
 182         qNameBuilder.setNamespace(0);
 183         qNameBuilder.setRevision(1);
 184         qNameBuilder.setLocalName(2);
 185
 186         pathBuilder.setNodeType(qNameBuilder);
 187         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER.ordinal());
 188
 189         nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
 190         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
 191         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 192
 193         YangInstanceIdentifier.PathArgument pathArgument =
 194             NormalizedNodeSerializer
 195                 .deSerialize(nodeBuilder.build(), pathBuilder.build());
 196
 197         assertEquals(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME), pathArgument);
 198
 199     }
 200
 201     @Test
 202     public void testDeSerializeNodeWithValue(){
 203         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 204         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 205         NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
 206
 207         qNameBuilder.setNamespace(0);
 208         qNameBuilder.setRevision(1);
 209         qNameBuilder.setLocalName(2);
 210
 211         pathBuilder.setNodeType(qNameBuilder);
 212         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER_WITH_VALUE.ordinal());
 213         pathBuilder.addAttribute(
 214             NormalizedNodeMessages.PathArgumentAttribute.newBuilder()
 215                 .setValue("foo").setType(ValueType.STRING_TYPE.ordinal()));
 216
 217         nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
 218         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
 219         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 220
 221         YangInstanceIdentifier.PathArgument pathArgument =
 222             NormalizedNodeSerializer
 223                 .deSerialize(nodeBuilder.build(), pathBuilder.build());
 224
 225         assertEquals(new YangInstanceIdentifier.NodeWithValue(TestModel.TEST_QNAME, "foo"), pathArgument);
 226
 227     }
 228     @Test
 229     public void testDeSerializeNodeIdentifierWithPredicates(){
 230         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 231         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 232         NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
 233
 234         qNameBuilder.setNamespace(0);
 235         qNameBuilder.setRevision(1);
 236         qNameBuilder.setLocalName(2);
 237
 238         pathBuilder.setNodeType(qNameBuilder);
 239         pathBuilder.setIntType(PathArgumentType.NODE_IDENTIFIER_WITH_PREDICATES.ordinal());
 240         pathBuilder.addAttribute(NormalizedNodeMessages.PathArgumentAttribute.newBuilder().setName(qNameBuilder).setValue(
 241             "foo").setType(ValueType.STRING_TYPE.ordinal()));
 242
 243         nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
 244         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
 245         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 246
 247         YangInstanceIdentifier.PathArgument pathArgument =
 248             NormalizedNodeSerializer
 249                 .deSerialize(nodeBuilder.build(), pathBuilder.build());
 250
 251         assertEquals(new YangInstanceIdentifier.NodeIdentifierWithPredicates(TestModel.TEST_QNAME,
 252             ImmutableMap.<QName, Object>of(TestModel.TEST_QNAME, "foo")), pathArgument);
 253
 254     }
 255     @Test
 256     public void testDeSerializeNodeAugmentationIdentifier(){
 257         NormalizedNodeMessages.Node.Builder nodeBuilder = NormalizedNodeMessages.Node.newBuilder();
 258         NormalizedNodeMessages.PathArgument.Builder pathBuilder = NormalizedNodeMessages.PathArgument.newBuilder();
 259         NormalizedNodeMessages.QName.Builder qNameBuilder = NormalizedNodeMessages.QName.newBuilder();
 260
 261         qNameBuilder.setNamespace(0);
 262         qNameBuilder.setRevision(1);
 263         qNameBuilder.setLocalName(2);
 264
 265         pathBuilder.setIntType(PathArgumentType.AUGMENTATION_IDENTIFIER.ordinal());
 266         pathBuilder.addAttribute(NormalizedNodeMessages.PathArgumentAttribute.newBuilder().setName(qNameBuilder).setType(ValueType.STRING_TYPE.ordinal()));
 267
 268         nodeBuilder.addCode(TestModel.TEST_QNAME.getNamespace().toString());
 269         nodeBuilder.addCode(TestModel.TEST_QNAME.getFormattedRevision());
 270         nodeBuilder.addCode(TestModel.TEST_QNAME.getLocalName());
 271
 272         YangInstanceIdentifier.PathArgument pathArgument =
 273             NormalizedNodeSerializer
 274                 .deSerialize(nodeBuilder.build(), pathBuilder.build());
 275
 276         assertEquals(new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.of(TestModel.TEST_QNAME)), pathArgument);
 277
 278     }
 279
 280
 281
 282 }