From 01fa20189495e721d55fd2c20f9aff074cd0523d Mon Sep 17 00:00:00 2001 From: Johann David Date: Wed, 20 Jan 2016 18:01:57 -0500 Subject: [PATCH] Add UnimgrDataChangeListenerTest class in org.opendaylight.unimgr.impl package Change-Id: Id0397d2ba431beea79851a677eb3310076ffeff5 Signed-off-by: Johann David (cherry picked from commit c9e6afc3c8087494af59557dec6f2d1102c6a0c6) --- .../impl/UnimgrDataChangeListenerTest.java | 181 ++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 impl/src/test/java/org/opendaylight/unimgr/impl/UnimgrDataChangeListenerTest.java diff --git a/impl/src/test/java/org/opendaylight/unimgr/impl/UnimgrDataChangeListenerTest.java b/impl/src/test/java/org/opendaylight/unimgr/impl/UnimgrDataChangeListenerTest.java new file mode 100644 index 00000000..be800d5c --- /dev/null +++ b/impl/src/test/java/org/opendaylight/unimgr/impl/UnimgrDataChangeListenerTest.java @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2016 CableLabs and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.unimgr.impl; + +import static org.junit.Assert.assertFalse; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.atLeast; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.unimgr.command.Command; +import org.opendaylight.unimgr.command.EvcCreateCommand; +import org.opendaylight.unimgr.command.EvcDeleteCommand; +import org.opendaylight.unimgr.command.EvcUpdateCommand; +import org.opendaylight.unimgr.command.TransactionInvoker; +import org.opendaylight.unimgr.command.UniCreateCommand; +import org.opendaylight.unimgr.command.UniDeleteCommand; +import org.opendaylight.unimgr.command.UniUpdateCommand; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.api.support.membermodification.MemberModifier; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({UnimgrMapper.class, + UnimgrDataChangeListener.class}) +public class UnimgrDataChangeListenerTest { + + @Mock private UnimgrDataChangeListener unimgrDataChangeListener; + @Mock private HashSet> listeners; + @Mock private DataBroker dataBroker; + @Mock private TransactionInvoker invoker; + + @Before + public void setUp() throws Exception { + unimgrDataChangeListener = mock(UnimgrDataChangeListener.class, Mockito.CALLS_REAL_METHODS); + MemberModifier.field(UnimgrDataChangeListener.class, "invoker").set(unimgrDataChangeListener, invoker); + } + + @SuppressWarnings({ "unchecked", "resource" }) + @Test + public void testUnimgrDataChangeListener() throws Exception { + final InstanceIdentifier path = mock(InstanceIdentifier.class); + final ListenerRegistration listenerRegistration = mock(ListenerRegistration.class); + PowerMockito.mockStatic(UnimgrMapper.class); + PowerMockito.when(UnimgrMapper.getUniTopologyIid()).thenReturn(path); + PowerMockito.when(UnimgrMapper.getEvcTopologyIid()).thenReturn(path); + PowerMockito.when(UnimgrMapper.getOvsdbTopologyIid()).thenReturn(path); + PowerMockito.whenNew(HashSet.class).withNoArguments().thenReturn(listeners); + when(listeners.add(any(ListenerRegistration.class))).thenReturn(true); + when(dataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), + any(InstanceIdentifier.class), + any(UnimgrDataChangeListener.class), + eq(DataChangeScope.SUBTREE))).thenReturn(listenerRegistration); + new UnimgrDataChangeListener(dataBroker, invoker); + assertFalse(listeners.isEmpty()); + verify(listeners, atLeast(3)).add(any(ListenerRegistration.class)); + verify(dataBroker, atLeast(3)).registerDataChangeListener(any(LogicalDatastoreType.class), + any(InstanceIdentifier.class), + any(UnimgrDataChangeListener.class), + eq(DataChangeScope.SUBTREE)); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Test + public void testOnDataChanged() { + final AsyncDataChangeEvent change = mock(AsyncDataChangeEvent.class); + final Map map = mock(Map.class); + when(change.getCreatedData()).thenReturn(map); + doNothing().when(unimgrDataChangeListener).create(any(Map.class)); + doNothing().when(unimgrDataChangeListener).update(any(Map.class)); + doNothing().when(unimgrDataChangeListener).delete(any(AsyncDataChangeEvent.class)); + unimgrDataChangeListener.onDataChanged(change); + verify(unimgrDataChangeListener).create(any(Map.class)); + verify(unimgrDataChangeListener).update(any(Map.class)); + verify(unimgrDataChangeListener).delete(any(AsyncDataChangeEvent.class)); + } + + @SuppressWarnings("unchecked") + @Test + public void testCreate() throws Exception { + // False case + unimgrDataChangeListener.create(null); + + // True case + final Map, DataObject> changes = mock(Map.class); + final UniCreateCommand uniCreate = mock(UniCreateCommand.class); + final EvcCreateCommand evcCreate = mock(EvcCreateCommand.class); + final List commands = mock(ArrayList.class); + PowerMockito.whenNew(ArrayList.class).withNoArguments() + .thenReturn((ArrayList) commands); + PowerMockito.whenNew(UniCreateCommand.class).withArguments(any(DataBroker.class), + any(Map.class)).thenReturn(uniCreate); + PowerMockito.whenNew(EvcCreateCommand.class).withArguments(any(DataBroker.class), + any(Map.class)).thenReturn(evcCreate); + when(commands.add(any(Command.class))).thenReturn(true); + doNothing().when(invoker).setCommands(any(ArrayList.class)); + doNothing().when(invoker).invoke(); + unimgrDataChangeListener.create(changes); + verify(invoker, times(1)).setCommands(any(List.class)); + verify(invoker, times(1)).invoke(); + } + + @SuppressWarnings("unchecked") + @Test + public void testUpdate() throws Exception { + // False case + unimgrDataChangeListener.update(null); + + // True case + final Map, DataObject> changes = mock(Map.class); + final UniUpdateCommand uniUpdate = mock(UniUpdateCommand.class); + final EvcUpdateCommand evcUpdate = mock(EvcUpdateCommand.class); + final List commands = mock(ArrayList.class); + PowerMockito.whenNew(ArrayList.class).withNoArguments() + .thenReturn((ArrayList) commands); + PowerMockito.whenNew(UniUpdateCommand.class).withArguments(any(DataBroker.class), + any(Map.class)).thenReturn(uniUpdate); + PowerMockito.whenNew(EvcUpdateCommand.class).withArguments(any(DataBroker.class), + any(Map.class)).thenReturn(evcUpdate); + when(commands.add(any(Command.class))).thenReturn(true); + doNothing().when(invoker).setCommands(any(ArrayList.class)); + doNothing().when(invoker).invoke(); + unimgrDataChangeListener.update(changes); + verify(invoker, times(1)).setCommands(any(List.class)); + verify(invoker, times(1)).invoke(); + } + + @SuppressWarnings("unchecked") + @Test + public void testDelete() throws Exception { + // False case + unimgrDataChangeListener.delete(null); + + // True case + final AsyncDataChangeEvent, DataObject> changes = mock(AsyncDataChangeEvent.class); + final UniDeleteCommand uniDelete = mock(UniDeleteCommand.class); + final EvcDeleteCommand evcDelete = mock(EvcDeleteCommand.class); + final List commands = mock(ArrayList.class); + PowerMockito.whenNew(ArrayList.class).withNoArguments() + .thenReturn((ArrayList) commands); + PowerMockito.whenNew(UniDeleteCommand.class).withArguments(any(DataBroker.class), + any(AsyncDataChangeEvent.class)).thenReturn(uniDelete); + PowerMockito.whenNew(EvcDeleteCommand.class).withArguments(any(DataBroker.class), + any(AsyncDataChangeEvent.class)).thenReturn(evcDelete); + when(commands.add(any(Command.class))).thenReturn(true); + doNothing().when(invoker).setCommands(any(ArrayList.class)); + doNothing().when(invoker).invoke(); + unimgrDataChangeListener.delete(changes); + verify(invoker, times(1)).setCommands(any(List.class)); + verify(invoker, times(1)).invoke(); + } +} -- 2.36.6