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

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