*/
package org.opendaylight.bgpcep.pcep.topology.provider;
-import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
import com.google.common.util.concurrent.FluentFuture;
import java.net.InetSocketAddress;
-import java.util.Map;
+import java.util.List;
import java.util.Optional;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.bgpcep.pcep.topology.provider.PCEPStatefulPeerProposal.LspDbVersionListener;
+import org.opendaylight.bgpcep.pcep.topology.provider.PCEPStatefulPeerProposal.SpeakerIdListener;
import org.opendaylight.mdsal.binding.api.DataBroker;
-import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.Stateful1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.Tlvs3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.Tlvs3Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.lsp.db.version.tlv.LspDbVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.lsp.db.version.tlv.LspDbVersionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev200720.speaker.entity.id.tlv.SpeakerEntityIdBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Tlvs1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.stateful.capability.tlv.StatefulBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.open.object.open.TlvsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.sync.optimizations.config.rev181109.PcepNodeSyncConfigBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint64;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class PCEPStatefulPeerProposalTest {
private static final InstanceIdentifier<Topology> TOPOLOGY_IID = InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(new TopologyId("topology")));
@Mock
private DataBroker dataBroker;
@Mock
- private FluentFuture<Optional<LspDbVersion>> listenableFutureMock;
+ private Registration listenerReg;
@Mock
- private ReadTransaction rt;
+ private FluentFuture<Optional<LspDbVersion>> listenableFutureMock;
+ @Captor
+ private ArgumentCaptor<DataTreeChangeListener<?>> captor;
+
private TlvsBuilder tlvsBuilder;
- @SuppressWarnings("unchecked")
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
tlvsBuilder = new TlvsBuilder().addAugmentation(new Tlvs1Builder()
.setStateful(new StatefulBuilder().addAugmentation(new Stateful1Builder().build()).build())
.build());
- doReturn(rt).when(dataBroker).newReadOnlyTransaction();
- doNothing().when(rt).close();
- doReturn(listenableFutureMock).when(rt)
- .read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
- doReturn(true).when(listenableFutureMock).isDone();
- doAnswer(invocation -> {
- final Runnable runnable = (Runnable) invocation.getArguments()[0];
- runnable.run();
- return null;
- }).when(listenableFutureMock).addListener(any(Runnable.class), any(Executor.class));
+ doReturn(listenerReg).when(dataBroker).registerTreeChangeListener(any(), captor.capture());
+ doNothing().when(listenerReg).close();
}
@Test
- public void testSetPeerProposalSuccess() throws InterruptedException, ExecutionException {
- doReturn(Optional.of(LSP_DB_VERSION)).when(listenableFutureMock).get();
- final PCEPStatefulPeerProposal peerProposal = new PCEPStatefulPeerProposal(dataBroker, TOPOLOGY_IID,
- SpeakerIdMapping.of());
- peerProposal.setPeerSpecificProposal(ADDRESS, tlvsBuilder);
- assertEquals(LSP_DB_VERSION, tlvsBuilder.augmentation(Tlvs3.class).getLspDbVersion());
+ public void testSetPeerProposalSuccess() throws Exception {
+ updateBuilder(() -> {
+ final var listeners = captor.getAllValues();
+ assertEquals(2, listeners.size());
+
+ // not entirely accurate, but works well enough
+ final var modPath = TOPOLOGY_IID.child(Node.class,
+ new NodeKey(ServerSessionManager.createNodeId(ADDRESS.getAddress())));
+
+ final var dbverRoot = mock(DataObjectModification.class);
+ doReturn(LSP_DB_VERSION).when(dbverRoot).dataAfter();
+ final var dbverMod = mock(DataTreeModification.class);
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
+ doReturn(dbverRoot).when(dbverMod).getRootNode();
+
+ for (var listener : listeners) {
+ if (listener instanceof LspDbVersionListener) {
+ listener.onDataTreeChanged(List.of(dbverMod));
+ }
+ }
+
+ // Mock lspdb
+ });
+ assertEquals(new Tlvs3Builder().setLspDbVersion(LSP_DB_VERSION).build(), tlvsBuilder.augmentation(Tlvs3.class));
}
@Test
- public void testSetPeerProposalWithEntityIdSuccess() throws InterruptedException, ExecutionException {
- doReturn(Optional.of(LSP_DB_VERSION)).when(listenableFutureMock).get();
- final PCEPStatefulPeerProposal peerProposal = new PCEPStatefulPeerProposal(dataBroker, TOPOLOGY_IID,
- SpeakerIdMapping.copyOf(Map.of(ADDRESS.getAddress(), SPEAKER_ID)));
- peerProposal.setPeerSpecificProposal(ADDRESS, tlvsBuilder);
+ public void testSetPeerProposalWithEntityIdSuccess() throws Exception {
+ updateBuilder(() -> {
+ final var listeners = captor.getAllValues();
+ assertEquals(2, listeners.size());
+
+ // not entirely accurate, but works well enough
+ final var modPath = TOPOLOGY_IID.child(Node.class,
+ new NodeKey(ServerSessionManager.createNodeId(ADDRESS.getAddress())));
+
+ final var dbverRoot = mock(DataObjectModification.class);
+ doReturn(LSP_DB_VERSION).when(dbverRoot).dataAfter();
+ final var dbverMod = mock(DataTreeModification.class);
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.OPERATIONAL, modPath)).when(dbverMod).getRootPath();
+ doReturn(dbverRoot).when(dbverMod).getRootNode();
+
+ final var speakerRoot = mock(DataObjectModification.class);
+ doReturn(new PcepNodeSyncConfigBuilder().setSpeakerEntityIdValue(SPEAKER_ID).build()).when(speakerRoot)
+ .dataAfter();
+ final var speakerMod = mock(DataTreeModification.class);
+ doReturn(DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, modPath)).when(speakerMod)
+ .getRootPath();
+ doReturn(speakerRoot).when(speakerMod).getRootNode();
+
+ for (var listener : listeners) {
+ if (listener instanceof SpeakerIdListener) {
+ listener.onDataTreeChanged(List.of(speakerMod));
+ } else if (listener instanceof LspDbVersionListener) {
+ listener.onDataTreeChanged(List.of(dbverMod));
+ }
+ }
+ });
final Tlvs3 aug = tlvsBuilder.augmentation(Tlvs3.class);
+ assertNotNull(aug);
assertEquals(LSP_DB_VERSION, aug.getLspDbVersion());
- assertArrayEquals(SPEAKER_ID, aug.getSpeakerEntityId().getSpeakerEntityIdValue());
+ assertEquals(new SpeakerEntityIdBuilder().setSpeakerEntityIdValue(SPEAKER_ID).build(),
+ aug.getSpeakerEntityId());
}
@Test
- public void testSetPeerProposalAbsent() throws InterruptedException, ExecutionException {
- doReturn(Optional.empty()).when(listenableFutureMock).get();
- final PCEPStatefulPeerProposal peerProposal = new PCEPStatefulPeerProposal(dataBroker, TOPOLOGY_IID,
- SpeakerIdMapping.of());
- peerProposal.setPeerSpecificProposal(ADDRESS, tlvsBuilder);
+ public void testSetPeerProposalAbsent() throws Exception {
+ updateBuilder();
assertNull(tlvsBuilder.augmentation(Tlvs3.class));
}
- @Test
- public void testSetPeerProposalFailure() throws InterruptedException, ExecutionException {
- doThrow(new InterruptedException()).when(listenableFutureMock).get();
- final PCEPStatefulPeerProposal peerProposal = new PCEPStatefulPeerProposal(dataBroker, TOPOLOGY_IID,
- SpeakerIdMapping.of());
- peerProposal.setPeerSpecificProposal(ADDRESS, tlvsBuilder);
- assertNull(tlvsBuilder.augmentation(Tlvs3.class));
+ private void updateBuilder() {
+ updateBuilder(null);
+ }
+
+ private void updateBuilder(final Runnable customizer) {
+ try (var proposal = new PCEPStatefulPeerProposal(dataBroker, TOPOLOGY_IID)) {
+ if (customizer != null) {
+ customizer.run();
+ }
+ proposal.setPeerSpecificProposal(ADDRESS, tlvsBuilder);
+ }
}
}
Code Review / bgpcep.git / blobdiff