southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbControllerUpdateCommandTest.java

   1 /*
   2  * Copyright (c) 2015 Inocybe Technologies 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.ovsdb.southbound.transactions.md;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.Mockito.doNothing;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.verify;
  17 import static org.mockito.Mockito.when;
  18
  19 import java.util.ArrayList;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Optional;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.Mockito;
  28 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  29 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  30 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  31 import org.opendaylight.ovsdb.lib.notation.Column;
  32 import org.opendaylight.ovsdb.lib.notation.UUID;
  33 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  34 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  35 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  36 import org.opendaylight.ovsdb.schema.openvswitch.Controller;
  37 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  38 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  39 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  46 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  47 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  48 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  50 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  51 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  52 import org.powermock.api.mockito.PowerMockito;
  53 import org.powermock.api.support.membermodification.MemberMatcher;
  54 import org.powermock.api.support.membermodification.MemberModifier;
  55 import org.powermock.core.classloader.annotations.PrepareForTest;
  56 import org.powermock.modules.junit4.PowerMockRunner;
  57 import org.powermock.reflect.Whitebox;
  58
  59 @RunWith(PowerMockRunner.class)
  60 @PrepareForTest({ OvsdbControllerUpdateCommand.class, SouthboundMapper.class, SouthboundUtil.class,
  61         InstanceIdentifier.class })
  62 public class OvsdbControllerUpdateCommandTest {
  63     private static final String BRIDGE_NAME = "br-int";
  64     private static final String NODE_ID = "OF|00:00:00:0c:29:70:45:9b";
  65
  66     private OvsdbControllerUpdateCommand ovsdbControllerUpdateCommand;
  67
  68     @Before
  69     public void setUp() {
  70         ovsdbControllerUpdateCommand = PowerMockito.mock(OvsdbControllerUpdateCommand.class,
  71                 Mockito.CALLS_REAL_METHODS);
  72     }
  73
  74     @Test
  75     public void testOvsdbControllerUpdateCommand() {
  76         OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
  77         TableUpdates updates = mock(TableUpdates.class);
  78         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
  79         OvsdbControllerUpdateCommand ovsdbControllerUpdateCommand1 = new OvsdbControllerUpdateCommand(key, updates,
  80                 dbSchema);
  81         assertEquals(key, Whitebox.getInternalState(ovsdbControllerUpdateCommand1, "key"));
  82         assertEquals(updates, Whitebox.getInternalState(ovsdbControllerUpdateCommand1, "updates"));
  83         assertEquals(dbSchema, Whitebox.getInternalState(ovsdbControllerUpdateCommand1, "dbSchema"));
  84     }
  85
  86     @Test
  87     public void testExecute() throws Exception {
  88         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
  89         updatedControllerRows.put(mock(UUID.class), mock(Controller.class));
  90         MemberModifier.field(OvsdbControllerUpdateCommand.class, "updatedControllerRows")
  91                 .set(ovsdbControllerUpdateCommand, updatedControllerRows);
  92         MemberModifier.suppress(MemberMatcher.method(OvsdbControllerUpdateCommand.class, "updateController",
  93                 ReadWriteTransaction.class, Map.class, Map.class));
  94         MemberModifier.suppress(MemberMatcher.method(OvsdbControllerUpdateCommand.class, "updateController",
  95                 ReadWriteTransaction.class, Map.class));
  96
  97         // updatedBridgeRows null case
  98         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
  99         ovsdbControllerUpdateCommand.execute(transaction);
 100         verify(ovsdbControllerUpdateCommand).updateController(any(ReadWriteTransaction.class), any(Map.class));
 101
 102         // updatedBridgeRows not null case
 103         Map<UUID, Bridge> updatedBridgeRows = new HashMap<>();
 104         updatedBridgeRows.put(mock(UUID.class), mock(Bridge.class));
 105         MemberModifier.field(OvsdbControllerUpdateCommand.class, "updatedBridgeRows").set(ovsdbControllerUpdateCommand,
 106                 updatedBridgeRows);
 107     }
 108
 109     @SuppressWarnings("unchecked")
 110     @Test
 111     public void testUpdateController1() throws Exception {
 112         Map<UUID, Bridge> updatedBridgeRows = new HashMap<>();
 113         Bridge bridge = mock(Bridge.class);
 114         updatedBridgeRows.put(mock(UUID.class), bridge);
 115
 116         PowerMockito.mockStatic(SouthboundMapper.class);
 117         List<ControllerEntry> controllerEntries = new ArrayList<>();
 118         controllerEntries.add(mock(ControllerEntry.class));
 119         when(SouthboundMapper.createControllerEntries(any(Bridge.class), any(Map.class))).thenReturn(controllerEntries);
 120         Column<GenericTableSchema, String> column = mock(Column.class);
 121         when(bridge.getNameColumn()).thenReturn(column);
 122         when(column.getData()).thenReturn(BRIDGE_NAME);
 123
 124         // suppress call to getControllerEntryIid()
 125         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 126         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 127         doReturn(mock(InstanceIdentifier.class)).when(ovsdbControllerUpdateCommand).getControllerEntryIid(
 128                 any(ControllerEntry.class), any(String.class));
 129         doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 130                 any(ControllerEntry.class));
 131         Whitebox.invokeMethod(ovsdbControllerUpdateCommand, "updateController", transaction, updatedControllerRows,
 132                 updatedBridgeRows);
 133         verify(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 134                 any(ControllerEntry.class));
 135         verify(bridge).getNameColumn();
 136     }
 137
 138     @SuppressWarnings("unchecked")
 139     @Test
 140     public void testUpdateController2() throws Exception {
 141         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 142         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 143         Map<InstanceIdentifier<Node>, Node> bridgeNodes = new HashMap<>();
 144         Node node = mock(Node.class);
 145         InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
 146         bridgeNodes.put(bridgeIid, node);
 147         PowerMockito.doReturn(bridgeNodes).when(ovsdbControllerUpdateCommand, "getBridgeNodes",
 148                 any(ReadWriteTransaction.class));
 149
 150         Whitebox.invokeMethod(ovsdbControllerUpdateCommand, "updateController", transaction, updatedControllerRows);
 151         PowerMockito.verifyPrivate(ovsdbControllerUpdateCommand).invoke("getBridgeNodes",
 152                 any(ReadWriteTransaction.class));
 153     }
 154
 155     @SuppressWarnings("unchecked")
 156     @Test
 157     public void testGetBridgeNodes() throws Exception {
 158         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 159         when(ovsdbControllerUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 160         InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
 161         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
 162         PowerMockito.mockStatic(SouthboundUtil.class);
 163         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 164         Node node = mock(Node.class);
 165         Optional<Node> ovsdbNode = Optional.of(node);
 166         when(SouthboundUtil.readNode(transaction, connectionIId)).thenReturn(ovsdbNode);
 167         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 168         when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 169
 170         List<ManagedNodeEntry> managedNodeEntries = new ArrayList<>();
 171         ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
 172         managedNodeEntries.add(managedNodeEntry);
 173         when(ovsdbNodeAugmentation.getManagedNodeEntry()).thenReturn(managedNodeEntries);
 174         InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
 175         OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
 176         when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
 177         when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(bridgeIid);
 178         Optional<Node> bridgeNode = Optional.of(node);
 179         when(SouthboundUtil.readNode(transaction, bridgeIid)).thenReturn(bridgeNode);
 180
 181         Map<InstanceIdentifier<Node>, Node> testBridgeNodes = new HashMap<>();
 182         testBridgeNodes.put(bridgeIid, node);
 183
 184         //verify if getBridgeNodes() returns expected value
 185         assertEquals(testBridgeNodes,
 186                 Whitebox.invokeMethod(ovsdbControllerUpdateCommand, "getBridgeNodes", transaction));
 187     }
 188
 189     @Test
 190     public void testGetControllerEntryIid() throws Exception {
 191         ControllerEntry controllerEntry = mock(ControllerEntry.class);
 192         OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class);
 193         when(ovsdbControllerUpdateCommand.getOvsdbConnectionInstance()).thenReturn(client);
 194         NodeKey nodeKey = mock(NodeKey.class);
 195         when(client.getNodeKey()).thenReturn(nodeKey);
 196         NodeId nodeId = mock(NodeId.class);
 197         when(nodeKey.getNodeId()).thenReturn(nodeId);
 198         when(nodeId.getValue()).thenReturn(NODE_ID);
 199         PowerMockito.whenNew(Uri.class).withAnyArguments().thenReturn(mock(Uri.class));
 200         PowerMockito.whenNew(NodeId.class).withAnyArguments().thenReturn(nodeId);
 201         PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(nodeKey);
 202         PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
 203         //PowerMockito.suppress(MemberMatcher.methodsDeclaredIn(InstanceIdentifier.class));
 204         when(controllerEntry.key()).thenReturn(mock(ControllerEntryKey.class));
 205         assertEquals(KeyedInstanceIdentifier.class, Whitebox
 206                 .invokeMethod(ovsdbControllerUpdateCommand, "getControllerEntryIid", controllerEntry, BRIDGE_NAME)
 207                 .getClass());
 208     }
 209 }