<properties>
<controller.model.version>1.11.1</controller.model.version>
- <odlparent.checkstyle.enforce>false</odlparent.checkstyle.enforce>
- <odlparent.spotbugs.enforce>false</odlparent.spotbugs.enforce>
</properties>
<dependencies>
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Future;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.CreateConnectivityServiceOutput;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.DeleteConnectivityServiceInput;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.DeleteConnectivityServiceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.DeleteConnectivityServiceOutput;
import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.TapiConnectivityService;
-import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.UpdateConnectivityServiceInput;
-import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307.UpdateConnectivityServiceOutput;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
try {
EVCDao evcDao = LegatoUtils.parseNodes(evc);
- LOG.trace("========" + evcDao.getUniVlanIdList().toString());
+ LOG.trace(" UniVlanIdList = {} ", evcDao.getUniVlanIdList().toString());
assert evcDao != null
&& evcDao.getUniIdList() != null && evcDao.getConnectionType() != null;
LOG.trace(" connection-type :{}, svc-type :{}", evcDao.getConnectionType(), evcDao.getSvcType());
dataBroker);
}
}
- LOG.trace("EVC_UUID_MAP_LIST " + EVC_UUID_MAP_LIST.toString());
+ LOG.trace("EVC_UUID_MAP_LIST {} ", EVC_UUID_MAP_LIST.toString());
} else {
if (evcDao.getSvcType().equalsIgnoreCase(LegatoConstants.EVPL)
|| evcDao.getSvcType().equalsIgnoreCase(LegatoConstants.EVPLAN)
LOG.trace("svc-type in payload should be epl, evpl, eplan, evplan, evptree");
}
- } catch (Exception ex) {
+ } catch (RuntimeException ex) {
LOG.error("Error in createConnection(). Err: ", ex);
}
assert evcDao.getUniVlanIdList() != null;
List<String> vlanIdList = LegatoUtils.validateVlanTag(evcDao);
- LOG.trace(" number of noOfVlan = " + vlanIdList.toString());
+ LOG.trace(" number of noOfVlan {} ", vlanIdList.toString());
if (vlanIdList.size() > 0) {
// delete existing EVC and create service
deleteConnection(evc);
} else {
LOG.trace("svc-type in payload should be epl, evpl, eplan, evplan, eptree, evptree");
}
- } catch (Exception ex) {
+ } catch (RuntimeException ex) {
LOG.error("Error in updateConnection(). Err: ", ex);
}
}
}
- @SuppressWarnings("checkstyle:illegalcatch")
- private void callUpdateConnectionService(
- UpdateConnectivityServiceInput updateConnectivityServiceInput,
- String evcId) {
- try {
- Future<RpcResult<UpdateConnectivityServiceOutput>> response = this.prestoConnectivityService
- .updateConnectivityService(updateConnectivityServiceInput);
-
- if (response.get().isSuccessful()) {
- LOG.trace("call Success = {}, response = {} ", response.get()
- .isSuccessful(), response.get().getResult());
-
- Optional<Evc> optionalEvc = LegatoUtils.readEvc(
- dataBroker,
- LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier
- .create(MefServices.class)
- .child(CarrierEthernet.class)
- .child(SubscriberServices.class)
- .child(Evc.class,
- new EvcKey(new EvcIdType(evcId))));
-
- // update EVC Node in OPERATIONAL DB
- if (optionalEvc.isPresent()) {
- LegatoUtils.deleteFromOperationalDB(InstanceIdentifier
- .create(MefServices.class)
- .child(CarrierEthernet.class)
- .child(SubscriberServices.class)
- .child(Evc.class, new EvcKey(new EvcIdType(evcId))), dataBroker);
-
- LegatoUtils.updateEvcInOperationalDB(optionalEvc.get(), EVC_IID_OPERATIONAL, dataBroker);
- }
-
- } else {
- LOG.trace("call Failure = {} >> {} ", response.get()
- .isSuccessful(), response.get().getErrors());
- }
- } catch (Exception ex) {
- LOG.error("Error in UpdateConnectivityServiceInput(). Err: ", ex);
- }
- }
-
@SuppressWarnings("checkstyle:illegalcatch")
private boolean callDeleteConnectionService(
DeleteConnectivityServiceInput deleteConnectivityServiceInput) {
try {
- this.prestoConnectivityService
+ Future<RpcResult<DeleteConnectivityServiceOutput>> response = this.prestoConnectivityService
.deleteConnectivityService(deleteConnectivityServiceInput);
- return true;
-
+ if (response.get().isSuccessful()) {
+ LOG.trace("delete call Success = {}, response = {} ", response.get()
+ .isSuccessful(), response.get().getResult());
+ return true;
+ }
} catch (Exception ex) {
LOG.error("Fail to call callDeleteConnectionService(). Err: ", ex);
- return false;
}
+ return false;
}
}
import java.util.List;
import java.util.Map;
-
import org.opendaylight.yangtools.yang.common.Uint16;
/*
*/
package org.opendaylight.unimgr.mef.legato.util;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.FluentFuture;
/*
* @author santanu.de@xoriant.com
} else {
vlanIdList.add(vlanId);
}
- uniVlanList.put(endPoint.getUniId().getValue().toString(), vlanIdList);
- uniIdList.add(endPoint.getUniId().getValue().toString());
+ uniVlanList.put(endPoint.getUniId().getValue(), vlanIdList);
+ uniIdList.add(endPoint.getUniId().getValue());
}
final EVCDao evcDao = new EVCDao();
CreateConnectivityServiceInputBuilder createConnServiceInputBuilder =
new CreateConnectivityServiceInputBuilder();
- switch (evcDao.getConnectionType().replace("-", "").toUpperCase()) {
+ switch (evcDao.getConnectionType().replace("-", "").toUpperCase(Locale.ROOT)) {
case LegatoConstants.POINTTOPOINT:
createConnServiceInputBuilder.setConnConstraint(new ConnConstraintBuilder()
.setServiceLevel(LegatoConstants.BEST_EFFORT).setIsExclusive(isExclusive)
UpdateConnectivityServiceInputBuilder updateConnServiceInputBuilder =
new UpdateConnectivityServiceInputBuilder();
- switch (evcDao.getConnectionType().replace("-", "").toUpperCase()) {
+ switch (evcDao.getConnectionType().replace("-", "").toUpperCase(Locale.ROOT)) {
case LegatoConstants.POINTTOPOINT:
updateConnServiceInputBuilder.setConnConstraint(
new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev180307
endpointList.add(endPointBuilder.build());
}
- endPointBuilder = null;
return endpointList;
}
.setLayerProtocolName(layerProtocolName).addAugmentation(EndPoint7.class,
LegatoUtils.buildUpdateEthConnectivityEndPointAugmentation(uniArr[1]));
}
-
- uniArr = null;
-
return endPointBuilder.build();
}
final FluentFuture<Optional<Evc>> linkFuture = read.read(store, evcId);
return linkFuture.get();
} catch (final InterruptedException | ExecutionException e) {
- LOG.error("Unable to read node with EVC Id {}, err: {} ", evcId, e);
+ LOG.error("Unable to read node with EVC Id {}, err: ", evcId, e);
}
return Optional.empty();
}
public static <T extends DataObject> Optional<T> readProfile(
- DataBroker dataBroker, LogicalDatastoreType store, InstanceIdentifier<T> child, Class<T> c) {
+ DataBroker dataBroker, LogicalDatastoreType store, InstanceIdentifier<T> child, Class<T> className) {
final ReadTransaction read = dataBroker.newReadOnlyTransaction();
- final InstanceIdentifier<T> profileId = child.firstIdentifierOf(c);
+ final InstanceIdentifier<T> profileId = child.firstIdentifierOf(className);
final FluentFuture<Optional<T>> profileFuture = read.read(store, profileId);
try {
return profileFuture.get();
}
}
+ @SuppressWarnings("checkstyle:lineLength")
public static Optional<?> readProfile(String string, DataBroker dataBroker, LogicalDatastoreType store,
InstanceIdentifier<?> child) {
final ReadTransaction read = dataBroker.newReadOnlyTransaction();
transaction.commit().get();
result = true;
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Unable to remove node ", nodeIdentifier, e);
+ LOG.error("Unable to remove node {} ", nodeIdentifier, e);
}
return result;
}
transaction.commit().get();
result = true;
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Unable to update node in OperationalDB() ", nodeIdentifier, e);
+ LOG.error("Unable to update node {} in OperationalDB() ", nodeIdentifier, e);
}
return result;
public static List<String> validateVlanTag(EVCDao evcDao) {
List<String> vlanIdList = new ArrayList<String>();
- List<String> vlanTagList = new ArrayList<String>();
+ List<String> vlanTagList;
for (String uniId : evcDao.getUniIdList()) {
vlanTagList = evcDao.getUniVlanIdList().get(uniId);
} else if (!vlanIdList.equals(vlanTagList)) {
LOG.error("All end points should have same vlan tags");
vlanIdList = new ArrayList<String>();
-
- return vlanIdList;
}
}
if (Collections.frequency(vlanIdList, "0") == vlanIdList.size()) {
public static boolean removeFlowFromConfigDatastore(InstanceIdentifier<?> nodeIdentifier,
DataBroker dataBroker) {
- LOG.trace("Removing EVC from CONFIGURATION datastore ", nodeIdentifier);
+ LOG.trace("Removing EVC from CONFIGURATION datastore {} ", nodeIdentifier);
boolean result = false;
final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.commit().get();
result = true;
} catch (InterruptedException | ExecutionException e) {
- LOG.error("Unable to remove evc from CONFIGURATION datastore ", nodeIdentifier, e);
+ LOG.error("Unable to remove evc {} from CONFIGURATION datastore ", nodeIdentifier, e);
}
return result;
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-
/*
* @author Om.SAwasthi@Xoriant.Com
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
.setEvcId(new EvcIdType(Constants.EVC_ID_TYPE))
.setConnectionType(ConnectionType.MultipointToMultipoint)
.setSvcType(MefServiceType.Eplan).build();
+
}
@SuppressWarnings({"unchecked"})
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
verify(transaction).commit();
-// verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
-// @Override
-// public boolean matches(final Object argument) {
-// return ((LoggingEvent) argument).getFormattedMessage()
-// .contains("Received a request to delete node");
-// }
-// }));
-
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-
/*
* @author Arif.Hussain@Xoriant.Com
* @author Om.SAwasthi@Xoriant.Com
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
verify(transaction).commit();
-// verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
-// @Override
-// public boolean matches(final Object argument) {
-// return ((LoggingEvent) argument).getFormattedMessage()
-// .contains("Received a request to delete node");
-// }
-// }));
}
@Test
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
/*
* @author OmS.awasthi@Xoriant.Com
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(Optional.empty());
+ .toReturn(Optional.empty());
legatoServiceController.onDataTreeChanged(collection);
verify(legatoServiceController, times(1)).add(any(DataTreeModification.class));
}
+ @SuppressWarnings("checkstyle:lineLength")
private DataTreeModification<Evc> getDataTree(final ModificationType modificationType, Evc before, Evc after) {
final DataObjectModification<Evc> evcDataObjModification = new DataObjectModification<Evc>() {
+
@Override
public Collection<DataObjectModification<? extends DataObject>> getModifiedChildren() {
return Collections.emptyList();
}
+ @Override
+ public <C extends ChildOf<? super Evc>> Collection<DataObjectModification<C>> getModifiedChildren(
+ Class<C> childType) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <H extends ChoiceIn<? super Evc> & DataObject, C extends ChildOf<? super H>> Collection<DataObjectModification<C>> getModifiedChildren(
+ Class<H> caseType, Class<C> childType) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
@Override
public <C extends Identifiable<K> & ChildOf<? super Evc>, K extends
Identifier<C>> DataObjectModification<C> getModifiedChildListItem(
return null;
}
+ @Override
+ public <H extends ChoiceIn<? super Evc> & DataObject, C extends Identifiable<K> & ChildOf<? super H>, K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(
+ Class<H> caseType, Class<C> listItem, K listKey) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
@Override
public <C extends ChildOf<? super Evc>> DataObjectModification<C> getModifiedChildContainer(Class<C> arg0) {
// TODO Auto-generated method stub
return null;
}
+ @Override
+ public <H extends ChoiceIn<? super Evc> & DataObject, C extends ChildOf<? super H>> DataObjectModification<C> getModifiedChildContainer(
+ Class<H> caseType, Class<C> child) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
@Override
public DataObjectModification<? extends DataObject> getModifiedChild(PathArgument arg0) {
// TODO Auto-generated method stub
public Evc getDataAfter() {
return after;
}
-
- @Override
- public <C extends ChildOf<? super Evc>> Collection<DataObjectModification<C>> getModifiedChildren(
- Class<C> childType) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public <H extends ChoiceIn<? super Evc> & DataObject, C extends ChildOf<? super H>> Collection<DataObjectModification<C>> getModifiedChildren(
- Class<H> caseType, Class<C> childType) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public <H extends ChoiceIn<? super Evc> & DataObject, C extends ChildOf<? super H>> DataObjectModification<C> getModifiedChildContainer(
- Class<H> caseType, Class<C> child) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public <H extends ChoiceIn<? super Evc> & DataObject, C extends Identifiable<K> & ChildOf<? super H>, K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(
- Class<H> caseType, Class<C> listItem, K listKey) {
- // TODO Auto-generated method stub
- return null;
- }
};
DataTreeModification<Evc> modifiedEvc = new DataTreeModification<Evc>() {
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-
/*
* @author Arif.Hussain@Xoriant.Com
@Mock private DataBroker dataBroker;
@SuppressWarnings("rawtypes")
@Mock private FluentFuture checkedFuture;
-
@Mock private WriteTransaction transaction;
@Mock private ReadTransaction readTxn ;
private EndPointBuilder endPointBuilder;
.setEvcId(new EvcIdType(Constants.EVC_ID_TYPE)).setSvcType(MefServiceType.Epl)
.setConnectionType(ConnectionType.PointToPoint).setCosNames(cosNamesBuilder.build())
.setEndPoints(new EndPointsBuilder().setEndPoint(endPointList).build()).build();
+
}
@SuppressWarnings("unchecked")
PowerMockito.stub(PowerMockito.method(
LegatoUtils.class, "buildCreateConnectivityServiceInput", EVCDao.class, String.class, List.class))
- .toReturn(future);
+ .toReturn(future);
// then
final Optional<Evc> optEvc = mock(Optional.class);
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(checkedFuture);
assertEquals(true, LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
verify(transaction).commit();
-
}
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-
-
/*
* @author Om.SAwasthi@Xoriant.Com
*/
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
.setConnectionType(ConnectionType.MultipointToMultipoint)
.setSvcType(MefServiceType.Evplan).build();
-// root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
-// when(mockAppender.getName()).thenReturn("MOCK");
-// root.addAppender(mockAppender);
-
}
@SuppressWarnings({"unchecked"})
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
-
/*
* @author Om.SAwasthi@Xoriant.Com
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
-import com.google.common.util.concurrent.ListenableFuture;
/*
* @author OmS.awasthi@Xoriant.Com
private TapiConnectivityService prestoConnectivityService;
@Mock
private DataBroker dataBroker;
-
@Mock
private WriteTransaction transaction;
@Mock
PowerMockito.stub(
PowerMockito.method(LegatoUtils.class,
"readEvc", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class))
- .toReturn(optEvc);
+ .toReturn(optEvc);
when(transaction.commit()).thenReturn(fluentFuture);
assertEquals(true,LegatoUtils.updateEvcInOperationalDB(evc, instanceIdentifier, dataBroker));
- verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(SubscriberServices.class));
+ verify(transaction).put(any(LogicalDatastoreType.class),
+ any(InstanceIdentifier.class),
+ any(SubscriberServices.class));
verify(transaction).commit();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.util.concurrent.FluentFuture;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
-
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.google.common.util.concurrent.FluentFuture;
/*
* @author Arif.Hussain@Xoriant.Com