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