import com.google.common.util.concurrent.Futures;
import java.net.InetAddress;
import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.netconf.topology.singleton.api.NetconfDOMTransaction;
-import org.opendaylight.netconf.topology.singleton.impl.NetconfDOMDataBroker;
+import org.opendaylight.netconf.topology.singleton.impl.ProxyDOMDataBroker;
import org.opendaylight.netconf.topology.singleton.impl.actors.NetconfNodeActor;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.messages.CreateInitialMasterActorData;
public final ExpectedException exception = ExpectedException.none();
private ActorRef masterRef;
- private NetconfDOMDataBroker slaveDataBroker;
- private DOMDataBroker masterDataBroker;
+ private ProxyDOMDataBroker slaveDataBroker;
private List<SourceIdentifier> sourceIdentifiers;
-
+ @Mock
+ private DOMDataBroker deviceDataBroker;
@Mock
private DOMDataReadOnlyTransaction readTx;
+ @Mock
+ private DOMRpcService domRpcService;
+ private YangInstanceIdentifier instanceIdentifier;
+ private LogicalDatastoreType storeType;
@Before
- public void setup() throws UnknownHostException {
+ public void setup() throws Exception {
initMocks(this);
system = ActorSystem.create();
sourceIdentifiers = Lists.newArrayList();
- // Create master data broker
-
- final DOMDataBroker delegateDataBroker = mock(DOMDataBroker.class);
- readTx = mock(DOMDataReadOnlyTransaction.class);
-
- doReturn(readTx).when(delegateDataBroker).newReadOnlyTransaction();
-
- final NetconfDOMTransaction masterDOMTransactions =
- new NetconfMasterDOMTransaction(remoteDeviceId, delegateDataBroker);
-
- masterDataBroker =
- new NetconfDOMDataBroker(system, remoteDeviceId, masterDOMTransactions);
+ //device read tx
+ doReturn(readTx).when(deviceDataBroker).newReadOnlyTransaction();
// Create slave data broker for testing proxy
-
- final NetconfDOMTransaction proxyDOMTransactions =
- new NetconfProxyDOMTransaction(remoteDeviceId, system, masterRef);
-
- slaveDataBroker = new NetconfDOMDataBroker(system, remoteDeviceId, proxyDOMTransactions);
-
-
+ slaveDataBroker =
+ new ProxyDOMDataBroker(system, remoteDeviceId, masterRef, Timeout.apply(5, TimeUnit.SECONDS));
+ initializeDataTest();
+ instanceIdentifier = YangInstanceIdentifier.EMPTY;
+ storeType = LogicalDatastoreType.CONFIGURATION;
}
@After
public void teardown() {
- JavaTestKit.shutdownActorSystem(system);
+ JavaTestKit.shutdownActorSystem(system, null, true);
system = null;
}
@Test
public void testRead() throws Exception {
+ // Message: NormalizedNodeMessage
+ final NormalizedNode<?, ?> outputNode = ImmutableContainerNodeBuilder.create()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create("TestQname")))
+ .withChild(ImmutableNodes.leafNode(QName.create("NodeQname"), "foo")).build();
+ final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultNormalizedNodeMessage =
+ Futures.immediateCheckedFuture(Optional.of(outputNode));
+ doReturn(resultNormalizedNodeMessage).when(readTx).read(storeType, instanceIdentifier);
- /* Initialize data on master */
+ final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultNodeMessageResponse =
+ slaveDataBroker.newReadOnlyTransaction().read(storeType, instanceIdentifier);
- initializeDataTest();
+ final Optional<NormalizedNode<?, ?>> resultNodeMessage =
+ resultNodeMessageResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
- final YangInstanceIdentifier instanceIdentifier = YangInstanceIdentifier.EMPTY;
- final LogicalDatastoreType storeType = LogicalDatastoreType.CONFIGURATION;
+ assertTrue(resultNodeMessage.isPresent());
+ assertEquals(resultNodeMessage.get(), outputNode);
+ }
+ @Test
+ public void testReadEmpty() throws Exception {
// Message: EmptyReadResponse
-
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultEmpty =
Futures.immediateCheckedFuture(Optional.absent());
-
doReturn(resultEmpty).when(readTx).read(storeType, instanceIdentifier);
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultEmptyResponse =
resultEmptyResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
assertEquals(resultEmptyMessage, Optional.absent());
+ }
- // Message: NormalizedNodeMessage
-
- final NormalizedNode<?, ?> outputNode = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create("TestQname")))
- .withChild(ImmutableNodes.leafNode(QName.create("NodeQname"), "foo")).build();
-
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultNormalizedNodeMessage =
- Futures.immediateCheckedFuture(Optional.of(outputNode));
-
- doReturn(resultNormalizedNodeMessage).when(readTx).read(storeType, instanceIdentifier);
-
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultNodeMessageResponse =
- slaveDataBroker.newReadOnlyTransaction().read(storeType, instanceIdentifier);
-
- final Optional<NormalizedNode<?, ?>> resultNodeMessage =
- resultNodeMessageResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
-
- assertTrue(resultNodeMessage.isPresent());
- assertEquals(resultNodeMessage.get(), outputNode);
-
+ @Test
+ public void testReadFail() throws Exception {
// Message: Throwable
-
final ReadFailedException readFailedException = new ReadFailedException("Fail", null);
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultThrowable =
Futures.immediateFailedCheckedFuture(readFailedException);
exception.expect(ReadFailedException.class);
resultThrowableResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
-
}
@Test
public void testExist() throws Exception {
-
- /* Initialize data on master */
-
- initializeDataTest();
-
- final YangInstanceIdentifier instanceIdentifier = YangInstanceIdentifier.EMPTY;
- final LogicalDatastoreType storeType = LogicalDatastoreType.CONFIGURATION;
-
// Message: True
-
final CheckedFuture<Boolean, ReadFailedException> resultTrue =
Futures.immediateCheckedFuture(true);
-
doReturn(resultTrue).when(readTx).exists(storeType, instanceIdentifier);
final CheckedFuture<Boolean, ReadFailedException> trueResponse =
final Boolean trueMessage = trueResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
assertEquals(true, trueMessage);
+ }
- // Message: False
-
- final CheckedFuture<Boolean, ReadFailedException> resultFalse = Futures.immediateCheckedFuture(false);
-
- doReturn(resultFalse).when(readTx).exists(storeType, instanceIdentifier);
-
- final CheckedFuture<Boolean, ReadFailedException> falseResponse =
- slaveDataBroker.newReadOnlyTransaction().exists(storeType,
- instanceIdentifier);
-
- final Boolean falseMessage = falseResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
-
- assertEquals(false, falseMessage);
-
+ @Test
+ public void testExistsNull() throws Exception {
// Message: False, result null
-
final CheckedFuture<Boolean, ReadFailedException> resultNull = Futures.immediateCheckedFuture(null);
-
doReturn(resultNull).when(readTx).exists(storeType, instanceIdentifier);
final CheckedFuture<Boolean, ReadFailedException> nullResponse =
final Boolean nullFalseMessage = nullResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
assertEquals(false, nullFalseMessage);
+ }
- // Message: Throwable
+ @Test
+ public void testExistsFalse() throws Exception {
+ // Message: False
+ final CheckedFuture<Boolean, ReadFailedException> resultFalse = Futures.immediateCheckedFuture(false);
+ doReturn(resultFalse).when(readTx).exists(storeType, instanceIdentifier);
+
+ final CheckedFuture<Boolean, ReadFailedException> falseResponse =
+ slaveDataBroker.newReadOnlyTransaction().exists(storeType,
+ instanceIdentifier);
+
+ final Boolean falseMessage = falseResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
+
+ assertEquals(false, falseMessage);
+ }
+ @Test
+ public void testExistsFail() throws Exception {
+ // Message: Throwable
final ReadFailedException readFailedException = new ReadFailedException("Fail", null);
final CheckedFuture<Boolean, ReadFailedException> resultThrowable =
Futures.immediateFailedCheckedFuture(readFailedException);
-
doReturn(resultThrowable).when(readTx).exists(storeType, instanceIdentifier);
final CheckedFuture<Boolean, ReadFailedException> resultThrowableResponse =
exception.expect(ReadFailedException.class);
resultThrowableResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
-
}
private void initializeDataTest() throws Exception {
final Future<Object> initialDataToActor =
- Patterns.ask(masterRef, new CreateInitialMasterActorData(masterDataBroker, sourceIdentifiers),
- TIMEOUT);
+ Patterns.ask(masterRef, new CreateInitialMasterActorData(deviceDataBroker, sourceIdentifiers,
+ domRpcService), TIMEOUT);
final Object success = Await.result(initialDataToActor, TIMEOUT.duration());
Code Review / netconf.git / blobdiff