netconf/mdsal-netconf-monitoring/src/test/java/org/opendaylight/controller/config/yang/netconf/mdsal/monitoring/MonitoringToMdsalWriterTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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.controller.config.yang.netconf.mdsal.monitoring;
   9
  10 import static org.mockito.ArgumentMatchers.any;
  11 import static org.mockito.ArgumentMatchers.eq;
  12 import static org.mockito.Mockito.doNothing;
  13 import static org.mockito.Mockito.doReturn;
  14 import static org.mockito.Mockito.inOrder;
  15 import static org.mockito.Mockito.verify;
  16 import static org.opendaylight.mdsal.common.api.CommitInfo.emptyFluentFuture;
  17
  18 import java.util.List;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.InOrder;
  23 import org.mockito.Mock;
  24 import org.mockito.junit.MockitoJUnitRunner;
  25 import org.opendaylight.mdsal.binding.api.DataBroker;
  26 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  27 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  28 import org.opendaylight.netconf.server.api.monitoring.NetconfMonitoringService;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.CapabilitiesBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.SchemasBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Sessions;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.Session;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.sessions.SessionBuilder;
  37 import org.opendaylight.yangtools.concepts.Registration;
  38 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  39 import org.opendaylight.yangtools.yang.common.Uint32;
  40
  41 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  42 public class MonitoringToMdsalWriterTest {
  43     private static final InstanceIdentifier<NetconfState> INSTANCE_IDENTIFIER =
  44             InstanceIdentifier.create(NetconfState.class);
  45
  46     @Mock
  47     private NetconfMonitoringService monitoring;
  48     @Mock
  49     private DataBroker dataBroker;
  50     @Mock
  51     private WriteTransaction writeTransaction;
  52     @Mock
  53     private Registration capabilityReg;
  54     @Mock
  55     private Registration sessionsReg;
  56
  57     private MonitoringToMdsalWriter writer;
  58
  59     @Before
  60     public void setUp() {
  61         doReturn(capabilityReg).when(monitoring).registerCapabilitiesListener(any());
  62         doReturn(sessionsReg).when(monitoring).registerSessionsListener(any());
  63
  64         doReturn(writeTransaction).when(dataBroker).newWriteOnlyTransaction();
  65
  66         doNothing().when(writeTransaction).put(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
  67         doNothing().when(writeTransaction).delete(eq(LogicalDatastoreType.OPERATIONAL), any());
  68         doReturn(emptyFluentFuture()).when(writeTransaction).commit();
  69
  70         writer = new MonitoringToMdsalWriter(dataBroker, monitoring);
  71     }
  72
  73     @Test
  74     public void testClose() throws Exception {
  75         doNothing().when(capabilityReg).close();
  76         doNothing().when(sessionsReg).close();
  77         writer.close();
  78         InOrder inOrder = inOrder(capabilityReg, sessionsReg, writeTransaction);
  79         inOrder.verify(sessionsReg).close();
  80         inOrder.verify(capabilityReg).close();
  81         inOrder.verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, INSTANCE_IDENTIFIER);
  82         inOrder.verify(writeTransaction).commit();
  83     }
  84
  85     @Test
  86     public void testOnCapabilityChanged() throws Exception {
  87         final InstanceIdentifier<Capabilities> capabilitiesId =
  88                 InstanceIdentifier.create(NetconfState.class).child(Capabilities.class);
  89         final Capabilities capabilities = new CapabilitiesBuilder().build();
  90         writer.onCapabilitiesChanged(capabilities);
  91         InOrder inOrder = inOrder(writeTransaction);
  92         inOrder.verify(writeTransaction).put(LogicalDatastoreType.OPERATIONAL, capabilitiesId, capabilities);
  93         inOrder.verify(writeTransaction).commit();
  94     }
  95
  96     @Test
  97     public void testOnSchemasChanged() throws Exception {
  98         final InstanceIdentifier<Schemas> schemasId =
  99                 InstanceIdentifier.create(NetconfState.class).child(Schemas.class);
 100         final Schemas schemas = new SchemasBuilder().build();
 101         writer.onSchemasChanged(schemas);
 102         InOrder inOrder = inOrder(writeTransaction);
 103         inOrder.verify(writeTransaction).put(LogicalDatastoreType.OPERATIONAL, schemasId, schemas);
 104         inOrder.verify(writeTransaction).commit();
 105     }
 106
 107     @Test
 108     public void testOnSessionStart() throws Exception {
 109         Session session = new SessionBuilder()
 110                 .setSessionId(Uint32.ONE)
 111                 .build();
 112         final InstanceIdentifier<Session> id =
 113                 InstanceIdentifier.create(NetconfState.class)
 114                         .child(Sessions.class)
 115                         .child(Session.class, session.key());
 116         writer.onSessionStarted(session);
 117         InOrder inOrder = inOrder(writeTransaction);
 118         inOrder.verify(writeTransaction).put(LogicalDatastoreType.OPERATIONAL, id, session);
 119         inOrder.verify(writeTransaction).commit();
 120     }
 121
 122     @Test
 123     public void testOnSessionEnd() throws Exception {
 124         Session session = new SessionBuilder()
 125                 .setSessionId(Uint32.ONE)
 126                 .build();
 127         final InstanceIdentifier<Session> id =
 128                 InstanceIdentifier.create(NetconfState.class)
 129                         .child(Sessions.class)
 130                         .child(Session.class, session.key());
 131         writer.onSessionEnded(session);
 132         InOrder inOrder = inOrder(writeTransaction);
 133         inOrder.verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, id);
 134         inOrder.verify(writeTransaction).commit();
 135     }
 136
 137     @Test
 138     public void testOnSessionsUpdated() throws Exception {
 139         Session session1 = new SessionBuilder()
 140                 .setSessionId(Uint32.ONE)
 141                 .build();
 142         Session session2 = new SessionBuilder()
 143                 .setSessionId(Uint32.valueOf(2))
 144                 .build();
 145         final InstanceIdentifier<Session> id1 =
 146                 InstanceIdentifier.create(NetconfState.class)
 147                         .child(Sessions.class)
 148                         .child(Session.class, session1.key());
 149         final InstanceIdentifier<Session> id2 =
 150                 InstanceIdentifier.create(NetconfState.class)
 151                         .child(Sessions.class)
 152                         .child(Session.class, session2.key());
 153         writer.onSessionsUpdated(List.of(session1, session2));
 154         InOrder inOrder = inOrder(writeTransaction);
 155         inOrder.verify(writeTransaction).put(LogicalDatastoreType.OPERATIONAL, id1, session1);
 156         inOrder.verify(writeTransaction).put(LogicalDatastoreType.OPERATIONAL, id2, session2);
 157         inOrder.verify(writeTransaction).commit();
 158     }
 159
 160     @Test
 161     public void testOnSessionInitiated() throws Exception {
 162         verify(monitoring).registerCapabilitiesListener(writer);
 163     }
 164 }