impl/src/test/java/org/opendaylight/unimgr/utils/NullAwareDatastoreGetterTest.java

   1 /*
   2  * Copyright (c) 2016 CableLabs 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 package org.opendaylight.unimgr.utils;
   9
  10
  11 import org.junit.Test;
  12 import org.opendaylight.yang.gen.v1.urn.mef.unimgr.ext.rev160725.ForwardingConstruct1;
  13 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.forwarding.constructs.ForwardingConstruct;
  14 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.g_forwardingconstruct.FcPort;
  15 import org.opendaylight.yang.gen.v1.urn.onf.core.network.module.rev160630.g_forwardingconstruct.FcSpec;
  16
  17 import java.util.ArrayList;
  18 import java.util.List;
  19 import java.util.Optional;
  20 import java.util.stream.Collectors;
  21
  22 import static org.junit.Assert.*;
  23 import static org.mockito.Matchers.eq;
  24 import static org.mockito.Mockito.mock;
  25 import static org.mockito.Mockito.when;
  26
  27 public class NullAwareDatastoreGetterTest {
  28
  29     @Test
  30     public void testCollectNotNull() {
  31         //given
  32         ForwardingConstruct fc = mock(ForwardingConstruct.class);
  33         FcSpec expected = mock(FcSpec.class);
  34
  35         when(fc.getFcSpec()).thenReturn(expected);
  36
  37         //when
  38         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fc)
  39                 .collect(x -> x::getFcSpec)
  40                 .get();
  41
  42         //then
  43         assertNotNull(actualOptional);
  44         assertTrue(actualOptional.isPresent());
  45         assertEquals(expected, actualOptional.get());
  46     }
  47
  48     @Test
  49     public void testCollectNull() {
  50         //given
  51         ForwardingConstruct fc = mock(ForwardingConstruct.class);
  52         when(fc.getFcSpec()).thenReturn(null);
  53
  54         //when
  55         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fc)
  56                 .collect(x -> x::getFcSpec)
  57                 .get();
  58
  59         //then
  60         assertNotNull(actualOptional);
  61         assertFalse(actualOptional.isPresent());
  62     }
  63
  64     @Test
  65     public void testCollectInputNull() {
  66         //given
  67         ForwardingConstruct fc = null;
  68
  69         //when
  70         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fc)
  71                 .collect(x -> x::getFcSpec)
  72                 .get();
  73
  74         //then
  75         assertNotNull(actualOptional);
  76         assertFalse(actualOptional.isPresent());
  77     }
  78
  79     @Test
  80     public void testCollectInputOptionalPresent() {
  81         //given
  82         ForwardingConstruct fc = mock(ForwardingConstruct.class);
  83         FcSpec expected = mock(FcSpec.class);
  84
  85         when(fc.getFcSpec()).thenReturn(expected);
  86
  87         Optional<ForwardingConstruct> fcOptional = Optional.of(fc);
  88
  89         //when
  90         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fcOptional)
  91                 .collect(x -> x::getFcSpec)
  92                 .get();
  93
  94         //then
  95         assertNotNull(actualOptional);
  96         assertTrue(actualOptional.isPresent());
  97         assertEquals(expected, actualOptional.get());
  98     }
  99
 100     @Test
 101     public void testCollectInputOptionalAbsent() {
 102         //given
 103         Optional<ForwardingConstruct> fcOptional = Optional.empty();
 104
 105         //when
 106         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fcOptional)
 107                 .collect(x -> x::getFcSpec)
 108                 .get();
 109
 110         //then
 111         assertNotNull(actualOptional);
 112         assertFalse(actualOptional.isPresent());
 113     }
 114
 115     @Test
 116     public void testCollectInputGoogleOptionalPresent() {
 117         //given
 118         ForwardingConstruct fc = mock(ForwardingConstruct.class);
 119         FcSpec expected = mock(FcSpec.class);
 120
 121         when(fc.getFcSpec()).thenReturn(expected);
 122
 123         com.google.common.base.Optional<ForwardingConstruct> fcOptional = com.google.common.base.Optional.of(fc);
 124
 125         //when
 126         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fcOptional)
 127                 .collect(x -> x::getFcSpec)
 128                 .get();
 129
 130         //then
 131         assertNotNull(actualOptional);
 132         assertTrue(actualOptional.isPresent());
 133         assertEquals(expected, actualOptional.get());
 134     }
 135
 136     @Test
 137     public void testCollectInputGoogleOptionalAbsent() {
 138         //given
 139         com.google.common.base.Optional<ForwardingConstruct> fcOptional = com.google.common.base.Optional.absent();
 140
 141         //when
 142         Optional<FcSpec> actualOptional = new NullAwareDatastoreGetter<>(fcOptional)
 143                 .collect(x -> x::getFcSpec)
 144                 .get();
 145
 146         //then
 147         assertNotNull(actualOptional);
 148         assertFalse(actualOptional.isPresent());
 149     }
 150
 151     @Test
 152     public void testCollectAugmentationNotNull() {
 153         //given
 154         ForwardingConstruct fc = mock(ForwardingConstruct.class);
 155         ForwardingConstruct1 expected = mock(ForwardingConstruct1.class);
 156
 157         when(fc.getAugmentation(eq(ForwardingConstruct1.class))).thenReturn(expected);
 158
 159         //when
 160         Optional<ForwardingConstruct1> actualOptional = new NullAwareDatastoreGetter<>(fc)
 161                 .collect(x -> x::getAugmentation, ForwardingConstruct1.class)
 162                 .get();
 163
 164         //then
 165         assertNotNull(actualOptional);
 166         assertTrue(actualOptional.isPresent());
 167         assertEquals(expected, actualOptional.get());
 168     }
 169
 170     @Test
 171     public void testCollectAugmentationNull() {
 172         //given
 173         ForwardingConstruct fc = mock(ForwardingConstruct.class);
 174         when(fc.getAugmentation(eq(ForwardingConstruct1.class))).thenReturn(null);
 175
 176         //when
 177         Optional<ForwardingConstruct1> actualOptional = new NullAwareDatastoreGetter<>(fc)
 178                 .collect(x -> x::getAugmentation, ForwardingConstruct1.class)
 179                 .get();
 180
 181         //then
 182         assertNotNull(actualOptional);
 183         assertFalse(actualOptional.isPresent());
 184     }
 185
 186     @Test
 187     public void testCollectManyNotNull() {
 188         //given
 189         ForwardingConstruct fc = mock(ForwardingConstruct.class);
 190
 191         FcPort fcPortA = mock(FcPort.class);
 192         FcPort fcPortZ = mock(FcPort.class);
 193
 194         List<FcPort> fcPorts = new ArrayList<>();
 195         fcPorts.add(fcPortA);
 196         fcPorts.add(fcPortZ);
 197
 198         when(fc.getFcPort()).thenReturn(fcPorts);
 199
 200         //when
 201         List<NullAwareDatastoreGetter<FcPort>> nullAwareDatastoreGetters = new NullAwareDatastoreGetter<>(fc)
 202                 .collectMany(x -> x::getFcPort);
 203
 204         //then
 205         assertNotNull(nullAwareDatastoreGetters);
 206         assertEquals(2, nullAwareDatastoreGetters.size());
 207
 208         NullAwareDatastoreGetter fcPortNadg1 = nullAwareDatastoreGetters.get(0);
 209         assertTrue(fcPortNadg1.get().isPresent());
 210         assertEquals(fcPortA, fcPortNadg1.get().get());
 211
 212         NullAwareDatastoreGetter fcPortNadg2 = nullAwareDatastoreGetters.get(1);
 213         assertTrue(fcPortNadg2.get().isPresent());
 214         assertEquals(fcPortZ, fcPortNadg2.get().get());
 215     }
 216
 217     @Test
 218     public void testCollectManyNull() {
 219         //given
 220         ForwardingConstruct fc = mock(ForwardingConstruct.class);
 221         List<FcPort> fcPorts = null;
 222
 223         when(fc.getFcPort()).thenReturn(fcPorts);
 224
 225         //when
 226         List<NullAwareDatastoreGetter<FcPort>> nullAwareDatastoreGetters = new NullAwareDatastoreGetter<>(fc)
 227                 .collectMany(x -> x::getFcPort);
 228
 229         //then
 230         assertNotNull(nullAwareDatastoreGetters);
 231         assertEquals(0, nullAwareDatastoreGetters.size());
 232     }
 233 }