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