gerrit.fd Code Review - hc2vpp.git/blob

   1 package io.fd.honeycomb.v3po.translate.util.write.registry;
   2
   3 import static org.hamcrest.CoreMatchers.anyOf;
   4 import static org.hamcrest.CoreMatchers.equalTo;
   5 import static org.hamcrest.CoreMatchers.hasItems;
   6 import static org.hamcrest.CoreMatchers.instanceOf;
   7 import static org.hamcrest.CoreMatchers.is;
   8 import static org.junit.Assert.assertEquals;
   9 import static org.junit.Assert.assertThat;
  10 import static org.mockito.Mockito.mock;
  11 import static org.mockito.Mockito.when;
  12
  13 import com.google.common.collect.ImmutableMap;
  14 import com.google.common.collect.Lists;
  15 import com.google.common.collect.Sets;
  16 import io.fd.honeycomb.v3po.translate.util.DataObjects;
  17 import io.fd.honeycomb.v3po.translate.write.Writer;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20 import org.junit.Test;
  21 import org.opendaylight.yangtools.yang.binding.DataObject;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23
  24 public class FlatWriterRegistryBuilderTest {
  25
  26
  27     @Test
  28     public void testRelationsBefore() throws Exception {
  29         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  30         /*
  31             1   ->  2   ->  3
  32                         ->  4
  33          */
  34         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject3.class));
  35         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject4.class));
  36         flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject2.class),
  37                 Lists.newArrayList(DataObjects.DataObject3.IID, DataObjects.DataObject4.IID));
  38         flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID);
  39         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  40                 flatWriterRegistryBuilder.getMappedHandlers();
  41
  42         final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  43         assertEquals(DataObjects.DataObject1.IID, typesInList.get(0));
  44         assertEquals(DataObjects.DataObject2.IID, typesInList.get(1));
  45         assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
  46         assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
  47     }
  48
  49     @Test
  50     public void testRelationsAfter() throws Exception {
  51         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  52         /*
  53             1   ->  2   ->  3
  54                         ->  4
  55          */
  56         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
  57         flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID);
  58         flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject3.class), DataObjects.DataObject2.IID);
  59         flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject4.class), DataObjects.DataObject2.IID);
  60         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  61                 flatWriterRegistryBuilder.getMappedHandlers();
  62
  63         final List<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  64         assertEquals(DataObjects.DataObject1.IID, typesInList.get(0));
  65         assertEquals(DataObjects.DataObject2.IID, typesInList.get(1));
  66         assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
  67         assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID)));
  68     }
  69
  70     @Test(expected = IllegalArgumentException.class)
  71     public void testRelationsLoop() throws Exception {
  72         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  73         /*
  74             1   ->  2   ->  1
  75          */
  76         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
  77         flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID);
  78         flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID);
  79     }
  80
  81     @Test(expected = IllegalArgumentException.class)
  82     public void testAddWriterTwice() throws Exception {
  83         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  84         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
  85         flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class));
  86     }
  87
  88     @Test
  89     public void testAddSubtreeWriter() throws Exception {
  90         final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder();
  91         flatWriterRegistryBuilder.subtreeAdd(
  92                 Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID,
  93                                 DataObjects.DataObject4.DataObject41.IID),
  94                 mockWriter(DataObjects.DataObject4.class));
  95         final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters =
  96                 flatWriterRegistryBuilder.getMappedHandlers();
  97         final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet());
  98
  99         assertEquals(DataObjects.DataObject4.IID, typesInList.get(0));
 100         assertEquals(1, typesInList.size());
 101     }
 102
 103     @Test
 104     public void testCreateSubtreeWriter() throws Exception {
 105         final Writer<?> forWriter = SubtreeWriter.createForWriter(Sets.newHashSet(
 106                 DataObjects.DataObject4.DataObject41.IID,
 107                 DataObjects.DataObject4.DataObject41.DataObject411.IID,
 108                 DataObjects.DataObject4.DataObject42.IID),
 109                 mockWriter(DataObjects.DataObject4.class));
 110         assertThat(forWriter, instanceOf(SubtreeWriter.class));
 111         assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes().size(), is(3));
 112         assertThat(((SubtreeWriter<?>) forWriter).getHandledChildTypes(), hasItems(DataObjects.DataObject4.DataObject41.IID,
 113                 DataObjects.DataObject4.DataObject42.IID, DataObjects.DataObject4.DataObject41.DataObject411.IID));
 114     }
 115
 116     @Test(expected = IllegalArgumentException.class)
 117     public void testCreateInvalidSubtreeWriter() throws Exception {
 118         SubtreeWriter.createForWriter(Sets.newHashSet(
 119                 InstanceIdentifier.create(DataObjects.DataObject3.class).child(DataObjects.DataObject3.DataObject31.class)),
 120                 mockWriter(DataObjects.DataObject4.class));
 121     }
 122
 123     @SuppressWarnings("unchecked")
 124     private Writer<? extends DataObject> mockWriter(final Class<? extends DataObject> doClass)
 125             throws NoSuchFieldException, IllegalAccessException {
 126         final Writer mock = mock(Writer.class);
 127         when(mock.getManagedDataObjectType()).thenReturn((InstanceIdentifier<?>) doClass.getDeclaredField("IID").get(null));
 128         return mock;
 129     }
 130
 131 }