/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
if (dao instanceof Contract) {
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Contract) {
- Contract contract = (Contract) dao;
+ Contract contract = (Contract) entry.getValue();
LOG.debug("Contract {} is Updated.", contract.getId().getValue());
UlnDatastoreApi.submitSecurityGroupsToDs(initSecurityGroupBuilder(contract).build());
}
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
processEndpoint(endpoint);
}
} else if (dao instanceof EndpointL3) {
- LOG.debug("Created EndpointL3 {}", (EndpointL3) dao);
+ LOG.debug("Created EndpointL3 {}", dao);
} else if (dao instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Created EndpointL3Prefix {}", (EndpointL3Prefix) dao);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Created EndpointL3Prefix {}", dao);
}
}
// Update
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) dao;
+ Endpoint endpoint = (Endpoint) entry.getValue();
LOG.debug("Updated Endpoint {}", endpoint);
if (validate(endpoint)) {
policyManager.registerTenant(endpoint.getTenant(), endpoint.getEndpointGroup());
processEndpoint(endpoint);
}
} else if (entry.getValue() instanceof EndpointL3) {
- LOG.debug("Updated EndpointL3 {}", (EndpointL3) dao);
+ LOG.debug("Updated EndpointL3 {}", entry.getValue());
} else if (entry.getValue() instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Updated EndpointL3Prefix {}", (EndpointL3Prefix) dao);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Updated EndpointL3Prefix {}", entry.getValue());
}
}
// Remove
continue;
}
if (old instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) dao;
+ Endpoint endpoint = (Endpoint) old;
LOG.debug("Removed Endpoint {}", endpoint);
removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
endpoint.getMacAddress());
} else if (old instanceof EndpointL3) {
- EndpointL3 endpoint = (EndpointL3) dao;
+ EndpointL3 endpoint = (EndpointL3) old;
LOG.debug("Removed EndpointL3 {}", endpoint);
removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
endpoint.getMacAddress());
} else if (old instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Removed EndpointL3Prefix {}", (EndpointL3Prefix) old);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Removed EndpointL3Prefix {}", old);
}
}
}
}
epLocBuilder.setUuid(epId);
Uuid faasSubnetId = getFaasSubnetId(endpoint);
- List<PrivateIps> privateIpAddresses = new ArrayList<PrivateIps>();
+ List<PrivateIps> privateIpAddresses = new ArrayList<>();
for (L3Address ip : endpoint.getL3Address()) {
PrivateIpsBuilder ipBuilder = new PrivateIpsBuilder();
ipBuilder.setIpAddress(ip.getIpAddress());
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class FaasPolicyManager implements DataChangeListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FaasPolicyManager.class);
private final DataBroker dataProvider;
protected final Map<Pair<EndpointGroupId, TenantId>, List<SubnetId>> epgSubnetsMap = new HashMap<>();
private final ConcurrentHashMap<TenantId, Uuid> mappedTenants = new ConcurrentHashMap<>();
- protected final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants = new ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>>();
+ protected final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants =
+ new ConcurrentHashMap<>();
public FaasPolicyManager(DataBroker dataBroker, ScheduledExecutorService executor) {
this.dataProvider = dataBroker;
/*
* tenant registrations
*/
- ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<ListenerRegistration<DataChangeListener>>();
+ ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<>();
ListenerRegistration<DataChangeListener> reg;
// contracts
reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
}
}
- private void registerFollowedEndpointgroup(TenantId gbpTenantId, EndpointGroupId epgId) {
+ @VisibleForTesting
+ void registerFollowedEndpointgroup(TenantId gbpTenantId, EndpointGroupId epgId) {
if (epgId == null) {
return;
}
if (val != null) {
return val;
}
- Uuid faasTenantId = null;
+ Uuid faasTenantId;
if (isUUid(tenantId.getValue())) {
faasTenantId = new Uuid(tenantId.getValue());
} else {
ArrayList<ListenerRegistration<DataChangeListener>> list = registeredTenants.remove(tenantId);
if (list != null) {
for (ListenerRegistration<DataChangeListener> reg : list) {
- reg.close();
+ if (reg != null)
+ reg.close();
}
LOG.debug("Unregistered tenant {}", tenantId);
}
return registeredTenants.containsKey(tenantId);
}
- private boolean handledPolicy(ResolvedPolicy policy) {
+ @VisibleForTesting
+ boolean handledPolicy(ResolvedPolicy policy) {
if (!policy.getConsumerTenantId().equals(policy.getProviderTenantId())) {
// FAAS always assumes consumer and provider EPGs belong to the same tenant
LOG.warn(
policy.getConsumerTenantId().getValue(), policy.getProviderTenantId().getValue());
return false;
}
- if (!isTenantRegistered(policy.getConsumerTenantId())) {
- return false;
- }
- return true;
+ return isTenantRegistered(policy.getConsumerTenantId());
}
private boolean isEqualService(ResolvedPolicy newPolicy, ResolvedPolicy oldPolicy) {
private void registerSubnetWithEpg(EndpointGroupId epgId, TenantId tenantId, SubnetId subnetId, boolean updateLn) {
synchronized (this) {
List<SubnetId> subnets = cloneAndGetEpgSubnets(epgId, tenantId);
- for (SubnetId id : subnets) {
- if (id.equals(subnetId)) {
- return;
- }
+ if(subnets.contains(subnetId)){
+ return;
}
subnets.add(subnetId);
epgSubnetsMap.put(new Pair<>(epgId, tenantId), subnets);
}
}
- private void removeLogicalNetwork(ResolvedPolicy oldPolicy) {
+ @VisibleForTesting
+ void removeLogicalNetwork(ResolvedPolicy oldPolicy) {
if (oldPolicy == null) {
return;
}
return builder;
}
- protected boolean needToCreateLogicalNetwork(ServiceCommunicationLayer comLayer, List<SubnetId> consSubnetIds,
+ @VisibleForTesting
+ boolean needToCreateLogicalNetwork(ServiceCommunicationLayer comLayer, List<SubnetId> consSubnetIds,
List<SubnetId> provSubnetIds, TenantId tenantId, ContractId contractId, EndpointGroup providerEpg,
EndpointGroup consumerEpg, ExternalImplicitGroup externalImplicitGroup) {
Optional<LogicalNetwork> lnOp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
return true;
}
Set<SubnetId> lnProvSubnets = new HashSet<>(logicalNet.getProviderNetwork().getGbpSubnetId());
- if (lnProvSubnets.size() != provSubnetIds.size() || !lnProvSubnets.containsAll(provSubnetIds)) {
- return true;
- }
- return false;
+ return lnProvSubnets.size() != provSubnetIds.size() || !lnProvSubnets.containsAll(
+ provSubnetIds);
}
private ServiceCommunicationLayer findLayerNetwork(TenantId tenantId, List<SubnetId> consSubnetIds,
return null;
}
- protected L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) {
+ @VisibleForTesting
+ L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L3Context> iid = IidFactory.l3ContextIid(tenantId, l3cId);
Optional<L3Context> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
return l2Op.get();
}
- protected L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) {
+ @VisibleForTesting
+ L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L2BridgeDomain> iid = IidFactory.l2BridgeDomainIid(tenantId, l2bId);
Optional<L2BridgeDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
return l2Op.get();
}
- protected L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) {
+ @VisibleForTesting
+ L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L2FloodDomain> iid = IidFactory.l2FloodDomainIid(tenantId, l2fId);
Optional<L2FloodDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
removeTenantLogicalNetwork(gbpTenantId, faasTenantId, true);
}
- private void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId, boolean unregister) {
+ @VisibleForTesting
+ void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId, boolean unregister) {
UlnDatastoreApi.removeTenantFromDsIfExists(faasTenantId);
synchronized (this) {
mappedTenants.remove(gbpTenantId);
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
if (dao instanceof Subnet) {
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Subnet) {
- Subnet subnet = (Subnet) dao;
+ Subnet subnet = (Subnet) entry.getValue();
LOG.debug("Subnet {} is Updated.", subnet.getId().getValue());
UlnDatastoreApi.submitSubnetToDs(initSubnetBuilder(subnet).build());
}
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Remove
for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
DataObject old = change.getOriginalData().get(iid);
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.security.rules.rev151013.security.rule.groups.attributes.security.rule.groups.container.SecurityRuleGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedContract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(UlnDatastoreApi.class)
+public class FaasContractManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Contract> contractIid;
+ private ContractId contractId = new ContractId("contractId");
+ private FaasContractManagerListener listener;
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ contractIid = mock(InstanceIdentifier.class);
+ dataProvider = mock(DataBroker.class);
+
+ listener = new FaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(contractIid);
+ }
+
+ @Test
+ public void testT() throws ReadFailedException {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSecurityGroupsToDs(any(SecurityRuleGroups.class));
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(woTx.submit()).thenReturn(futureVoid);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+
+ CheckedFuture<Optional<MappedContract>, ReadFailedException> futureMappedContract = mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL, FaasIidFactory.mappedContractIid(gbpTenantId, contractId)))
+ .thenReturn(futureMappedContract);
+ Optional<MappedContract> optMappedContract = mock(Optional.class);
+ when(optMappedContract.isPresent()).thenReturn(true);
+ when(futureMappedContract.checkedGet()).thenReturn(optMappedContract);
+
+ Contract contract = new ContractBuilder().setId(contractId).build();
+ tester.setDataObject(contractIid, contract);
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ private DataObject makeTestContract() {
+ ContractBuilder builder = new ContractBuilder();
+ builder.setId(new ContractId("b4511aac-ae43-11e5-bf7f-feff819cdc9f"));
+ return builder.build();
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.faas.endpoint.rev151009.FaasEndpointContextInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInput;
+
+public class FaasEndpointAugCovrgTest {
+
+ EpRendererAugmentationRegistry epRendererAugmentationRegistry;
+
+ @Before
+ public void init() {
+ epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);
+ }
+
+ @Test
+ public void testBuildEndpointAugmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterEndpointInput registerEndpointInput = mock(RegisterEndpointInput.class);
+ FaasEndpointContextInput pix = mock(FaasEndpointContextInput.class);
+
+ when(registerEndpointInput.getAugmentation(FaasEndpointContextInput.class)).thenReturn(pix);
+ aug.buildEndpointAugmentation(registerEndpointInput);
+
+ when(registerEndpointInput.getAugmentation(FaasEndpointContextInput.class)).thenReturn(null);
+ aug.buildEndpointAugmentation(registerEndpointInput);
+ aug.close();
+ }
+
+ @Test
+ public void testBuildEndpointL3Augmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterEndpointInput registerEndpointInput = mock(RegisterEndpointInput.class);
+
+ aug.buildEndpointL3Augmentation(registerEndpointInput);
+ aug.close();
+ }
+
+ @Test
+ public void testBuildL3PrefixEndpointAugmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterL3PrefixEndpointInput registerL3PrefixEndpointInput = mock(RegisterL3PrefixEndpointInput.class);
+
+ aug.buildL3PrefixEndpointAugmentation(registerL3PrefixEndpointInput);
+ aug.close();
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3PrefixBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasEndpointManagerListenerCovrgTest {
+
+ private static final L2BridgeDomainId L_2_BRIDGE_DOMAIN_ID = new L2BridgeDomainId("L2BridgeDomainId");
+ private static final MacAddress MAC_ADDRESS = new MacAddress("00:00:00:00:35:02");
+
+ private InstanceIdentifier<Endpoint> epIid;
+ private FaasEndpointManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private SubnetId subnetId = new SubnetId("subnetId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+ private FaasPolicyManager faasPolicyManager;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() throws ReadFailedException {
+ MappedEndpointKey mappedEndpointKey = new MappedEndpointKey(L_2_BRIDGE_DOMAIN_ID, MAC_ADDRESS);
+
+ dataProvider = mock(DataBroker.class);
+
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(woTx.submit()).thenReturn(futureVoid);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ doNothing().when(woTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+
+ CheckedFuture<Optional<MappedEndpoint>, ReadFailedException> futureMappedEndpoint = mock(CheckedFuture.class);
+ Optional<MappedEndpoint> optMappedEndpoint = mock(Optional.class);
+ when(optMappedEndpoint.isPresent()).thenReturn(false);
+ when(futureMappedEndpoint.checkedGet()).thenReturn(optMappedEndpoint);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEndpointIid(gbpTenantId, mappedEndpointKey))).thenReturn(futureMappedEndpoint);
+
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ epIid = mock(InstanceIdentifier.class);
+ faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ listener = new FaasEndpointManagerListener(faasPolicyManager, dataProvider, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(epIid);
+ }
+
+ @Test
+ public void testOnDataChanged_Endpoint() {
+ Endpoint ep = new EndpointBuilder().setTenant(gbpTenantId)
+ .setL2Context(L_2_BRIDGE_DOMAIN_ID)
+ .setMacAddress(MAC_ADDRESS)
+ .build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testOnDataChanged_EndpointL3() {
+ EndpointL3 ep = new EndpointL3Builder().setTenant(gbpTenantId)
+ .setL2Context(L_2_BRIDGE_DOMAIN_ID)
+ .setMacAddress(MAC_ADDRESS)
+ .build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testOnDataChanged_EndpointL3Prefix() {
+ EndpointL3Prefix ep = new EndpointL3PrefixBuilder().setTenant(gbpTenantId).build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;\r
+\r
+public class FaasIidFactoryTest {\r
+\r
+ @Test\r
+ public void testLogicalNetworksIid() {\r
+ assertNotNull(FaasIidFactory.logicalNetworksIid());\r
+ }\r
+\r
+ @Test\r
+ public void testLogicalNetworkIid() {\r
+ EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");\r
+ TenantId consumerTenantId = new TenantId("consumerTenantId");\r
+ ContractId contractId = new ContractId("contractId");\r
+ EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");\r
+ TenantId providerTenantId = new TenantId("providerTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.logicalNetworkIid(consumerEpgId, consumerTenantId, contractId, providerEpgId,\r
+ providerTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedTenantsEntitiesIid() {\r
+ assertNotNull(FaasIidFactory.mappedTenantsEntitiesIid());\r
+ }\r
+\r
+ @Test\r
+ public void testMappedSubnetIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ SubnetId subnetId = new SubnetId("subnetId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedTenantIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedTenantIid(gbpTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedEntityIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedEntityIid(gbpTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedContractIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ ContractId contractId = new ContractId("contractId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedContractIid(gbpTenantId, contractId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedEndpointIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ MappedEndpointKey mappedEndpointKey =\r
+ new MappedEndpointKey(new L2BridgeDomainId("L2BridgeDomainId"), new MacAddress("00:00:00:00:35:02"));\r
+\r
+ assertNotNull(FaasIidFactory.mappedEndpointIid(gbpTenantId, mappedEndpointKey));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+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.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.groupbasedpolicy.util.TenantUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.LogicalNetworks;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.LogicalNetworksBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ScopeType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ServiceCommunicationLayer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetwork;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ConsumerNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ProviderNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedEntity;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedTenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3ContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({UlnDatastoreApi.class})
+public class FaasPolicyManagerCovrgTest {
+
+ private InstanceIdentifier<DataObject> policyId;
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
+ DataBroker dataProvider;
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
+ .availableProcessors());
+ EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");
+ SubnetId consumerSubnet = new SubnetId("consumerSubnet");
+ SubnetId providerSubnet = new SubnetId("providerSubnet");
+ EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");
+ ContractId contractId = new ContractId("contractId");
+ TenantId tenantId = new TenantId("tenantId");
+ Uuid faasTenantId = new Uuid("0eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ Uuid faasSecRulesId = new Uuid("1eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ L3ContextId l3Context = new L3ContextId("l3ContextId");
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ SubnetId subnetId = new SubnetId("subnetId");
+ Uuid dummyUuid1 = new Uuid("2eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ Uuid dummyUuid2 = new Uuid("3eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() throws Exception {
+ policyId = mock(InstanceIdentifier.class);
+ change = mock(AsyncDataChangeEvent.class);
+ policyId = mock(InstanceIdentifier.class);
+ dataProvider = mock(DataBroker.class);
+
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid =
+ mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(futureVoid);
+
+ Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
+ removedPaths.add(policyId);
+ when(change.getRemovedPaths()).thenReturn(removedPaths);
+ }
+
+ @Test
+ public void testConstructor() throws Exception {
+ FaasPolicyManager other = new MockFaasPolicyManager(dataProvider, executor);
+
+ verify(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class)
+ .child(ResolvedPolicy.class)
+ .build(), other, AsyncDataBroker.DataChangeScope.SUBTREE);
+ other.close();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRegisterTenant() throws Exception {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ CheckedFuture<Optional<MappedTenant>, ReadFailedException> futureMappedTenant =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedTenantIid(tenantId))).thenReturn(futureMappedTenant);
+ Optional<MappedTenant> optMappedTenant = mock(Optional.class);
+ when(optMappedTenant.isPresent()).thenReturn(false);
+ when(futureMappedTenant.checkedGet()).thenReturn(optMappedTenant);
+
+ CheckedFuture<Optional<Tenant>, ReadFailedException> futureTenant =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION,
+ TenantUtils.tenantIid(tenantId))).thenReturn(futureTenant);
+ Optional<Tenant> optTenant = mock(Optional.class);
+ when(futureTenant.checkedGet()).thenReturn(optTenant);
+
+ CheckedFuture<Optional<MappedEntity>, ReadFailedException> futureMappedEntity =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEntityIid(tenantId))).thenReturn(futureMappedEntity);
+ Optional<MappedEntity> optMappedEntity = mock(Optional.class);
+ when(futureMappedEntity.checkedGet()).thenReturn(optMappedEntity);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(futureResolvedPolicies);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(optResolvedPolicies.isPresent()).thenReturn(false);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+
+ CheckedFuture<Optional<LogicalNetworks>, ReadFailedException> futureLogicalNetworks =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworksIid())).thenReturn(futureLogicalNetworks);
+ LogicalNetworks logicalNetworks = new LogicalNetworksBuilder()
+ .setLogicalNetwork( new ArrayList<LogicalNetwork>())
+ .build();
+ Optional<LogicalNetworks> optLogicalNetworks = mock(Optional.class);
+ when(optLogicalNetworks.isPresent()).thenReturn(true);
+ when(optLogicalNetworks.get()).thenReturn(logicalNetworks);
+ when(futureLogicalNetworks.checkedGet()).thenReturn(optLogicalNetworks);
+
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(policyManager).removeTenantLogicalNetwork(tenantId, faasTenantId, false);
+
+ policyManager.registerTenant(tenantId, epgId);
+ }
+
+ @Test
+ public void testRegisterTenant_null(){
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(policyManager).registerTenant(tenantId, null);
+
+ policyManager.registerTenant(tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRemoveTenantLogicalNetwork() throws ReadFailedException {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+
+ CheckedFuture<Optional<LogicalNetworks>, ReadFailedException> futureLogicalNetworks =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworksIid())).thenReturn(futureLogicalNetworks);
+ List<LogicalNetwork> lns = new ArrayList<>();
+ LogicalNetwork ln = new LogicalNetworkBuilder()
+ .setConsumerEpgId(consumerEpgId)
+ .setConsumerTenantId(tenantId)
+ .setContractId(contractId)
+ .setProviderEpgId(providerEpgId)
+ .setProviderTenantId(tenantId)
+ .build();
+ lns.add(ln);
+ LogicalNetworks logicalNetworks = new LogicalNetworksBuilder()
+ .setLogicalNetwork(lns)
+ .build();
+ Optional<LogicalNetworks> optLogicalNetworks = mock(Optional.class);
+ when(optLogicalNetworks.isPresent()).thenReturn(true);
+ when(optLogicalNetworks.get()).thenReturn(logicalNetworks);
+ when(futureLogicalNetworks.checkedGet()).thenReturn(optLogicalNetworks);
+
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ when(rwTx.read(eq(LogicalDatastoreType.OPERATIONAL),
+ eq(FaasIidFactory.logicalNetworkIid(consumerEpgId, tenantId, contractId,
+ providerEpgId, tenantId)))).thenReturn(futureLogicalNetwork);
+ Optional<LogicalNetwork> optionalLogicalNetwork = mock(Optional.class);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optionalLogicalNetwork);
+
+ CheckedFuture<Optional<MappedEntity>, ReadFailedException> futureMappedEntity =
+ mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEntityIid(tenantId))).thenReturn(futureMappedEntity);
+ Optional<MappedEntity> optMappedEntity = mock(Optional.class);
+ when(optMappedEntity.isPresent()).thenReturn(true);
+ when(futureMappedEntity.checkedGet()).thenReturn(optMappedEntity);
+
+ CheckedFuture<Optional<MappedTenant>, ReadFailedException> futureMappedTenant =
+ mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedTenantIid(tenantId))).thenReturn(futureMappedTenant);
+ Optional<MappedTenant> optMappedTenant = mock(Optional.class);
+ when(optMappedTenant.isPresent()).thenReturn(true);
+ when(futureMappedTenant.checkedGet()).thenReturn(optMappedTenant);
+
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeTenantFromDsIfExists(any(Uuid.class));
+
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+
+ policyManager.removeTenantLogicalNetwork(tenantId, faasTenantId);
+ }
+
+ @Test
+ public void testUnregisterTenant() throws Exception {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.unregisterTenant(tenantId);
+ }
+
+ @Test
+ public void testIsUuid(){
+ assertFalse(FaasPolicyManager.isUUid(null));
+ assertFalse(FaasPolicyManager.isUUid("non-matching string"));
+ assertTrue(FaasPolicyManager.isUUid("12345678-1234-5123-b123-0123456789ab"));
+ }
+
+ @Test
+ public void testHandledPolicy_notEquals(){
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ResolvedPolicy policy = new ResolvedPolicyBuilder()
+ .setConsumerTenantId(new TenantId("t1"))
+ .setProviderTenantId(new TenantId("t2"))
+ .build();
+
+ assertFalse(policyManager.handledPolicy(policy));
+ }
+
+ @Test
+ public void testRegisterFollowedEndpointgroup(){
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.registerFollowedEndpointgroup(tenantId, null);
+ policyManager.registerFollowedEndpointgroup(tenantId, epgId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRegisterSubnetWithEpg() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(futureResolvedPolicies);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(optResolvedPolicies.isPresent()).thenReturn(false);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+
+
+ policyManager.registerSubnetWithEpg(epgId, tenantId, subnetId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadEndpointGroup() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<EndpointGroup>, ReadFailedException> futureEndpointGroup =
+ mock(CheckedFuture.class);
+ Optional<EndpointGroup> optEndpointGroup = mock(Optional.class);
+ when(optEndpointGroup.isPresent()).thenReturn(true);
+ when(futureEndpointGroup.checkedGet()).thenReturn(optEndpointGroup);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.endpointGroupIid(tenantId, epgId))).thenReturn(futureEndpointGroup);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readEndpointGroup(epgId, tenantId);
+
+ when(optEndpointGroup.isPresent()).thenReturn(false);
+ policyManager.readEndpointGroup(epgId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadSubnet() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<Subnet>, ReadFailedException> futureSubnet =
+ mock(CheckedFuture.class);
+ Optional<Subnet> optSubnet = mock(Optional.class);
+ when(optSubnet.isPresent()).thenReturn(true);
+ when(futureSubnet.checkedGet()).thenReturn(optSubnet);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetId))).thenReturn(futureSubnet);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readSubnet(subnetId, tenantId);
+
+ when(optSubnet.isPresent()).thenReturn(false);
+ policyManager.readSubnet(subnetId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL3ContextInstance() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L3Context>, ReadFailedException> futureL3Context =
+ mock(CheckedFuture.class);
+ Optional<L3Context> optL3Context = mock(Optional.class);
+ when(optL3Context.isPresent()).thenReturn(true);
+ when(futureL3Context.checkedGet()).thenReturn(optL3Context);
+
+ L3ContextId l3cId = new L3ContextId("l3cId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l3ContextIid(tenantId, l3cId))).thenReturn(futureL3Context);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL3ContextInstance(tenantId, l3cId);
+
+ when(optL3Context.isPresent()).thenReturn(false);
+ policyManager.readL3ContextInstance(tenantId, l3cId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL2BridgeDomainInstance() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L2BridgeDomain>, ReadFailedException> futureL2BridgeDomain =
+ mock(CheckedFuture.class);
+ Optional<L2BridgeDomain> optL2BridgeDomain = mock(Optional.class);
+ when(optL2BridgeDomain.isPresent()).thenReturn(true);
+ when(futureL2BridgeDomain.checkedGet()).thenReturn(optL2BridgeDomain);
+
+ L2BridgeDomainId l2bId = new L2BridgeDomainId("l2bId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId,
+ l2bId))).thenReturn(futureL2BridgeDomain);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL2BridgeDomainInstance(tenantId, l2bId);
+
+ when(optL2BridgeDomain.isPresent()).thenReturn(false);
+ policyManager.readL2BridgeDomainInstance(tenantId, l2bId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL2FloodDomain() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L2FloodDomain>, ReadFailedException> futureL2FloodDomain =
+ mock(CheckedFuture.class);
+ Optional<L2FloodDomain> optL2FloodDomain = mock(Optional.class);
+ when(optL2FloodDomain.isPresent()).thenReturn(true);
+ when(futureL2FloodDomain.checkedGet()).thenReturn(optL2FloodDomain);
+
+ L2FloodDomainId l2fId = new L2FloodDomainId("l2fId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l2FloodDomainIid(tenantId,
+ l2fId))).thenReturn(futureL2FloodDomain);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL2FloodDomain(l2fId, tenantId);
+
+ when(optL2FloodDomain.isPresent()).thenReturn(false);
+ policyManager.readL2FloodDomain(l2fId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testNeedToCreateLogicalNetwork() throws ReadFailedException {
+
+ ServiceCommunicationLayer comLayer = ServiceCommunicationLayer.Layer2;
+ List<SubnetId> consSubnetIds = new ArrayList<>();
+ SubnetId consSubnetId = new SubnetId("consSubnetId");
+ consSubnetIds.add(consSubnetId);
+ List<SubnetId> provSubnetIds = new ArrayList<>();
+ SubnetId provSubnetId = new SubnetId("provSubnetId");
+ provSubnetIds.add(provSubnetId);
+ ContractId contractId = new ContractId("contractId");
+ EndpointGroup providerEpg = new EndpointGroupBuilder()
+ .setId(providerEpgId)
+ .build();
+ EndpointGroup consumerEpg = new EndpointGroupBuilder()
+ .setId(consumerEpgId)
+ .build();
+ ExternalImplicitGroup externalImplicitGroup = ExternalImplicitGroup.ProviderEpg;
+
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ Optional<LogicalNetwork> optLogicalNetwork = mock(Optional.class);
+ when(optLogicalNetwork.isPresent()).thenReturn(true);
+ LogicalNetwork logicalNet =
+ new LogicalNetworkBuilder()
+ .setCommunicationLayer(ServiceCommunicationLayer.Layer2)
+ .setConsumerNetwork(
+ new ConsumerNetworkBuilder().setNetworkScopeType(ScopeType.Private)
+ .setGbpSubnetId(consSubnetIds)
+ .build())
+ .setProviderNetwork(
+ new ProviderNetworkBuilder().setNetworkScopeType(ScopeType.Public)
+ .setGbpSubnetId(provSubnetIds)
+ .build())
+ .build();
+ when(optLogicalNetwork.get()).thenReturn(logicalNet);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optLogicalNetwork);
+
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworkIid(consumerEpg.getId(), tenantId, contractId,
+ providerEpg.getId(), tenantId))).thenReturn(futureLogicalNetwork);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.needToCreateLogicalNetwork(comLayer, consSubnetIds, provSubnetIds, tenantId,
+ contractId, providerEpg, consumerEpg, externalImplicitGroup);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRemoveLogicalNetwork()
+ throws ReadFailedException, TransactionCommitFailedException {
+ ServiceCommunicationLayer comLayer = ServiceCommunicationLayer.Layer2;
+ List<SubnetId> consSubnetIds = new ArrayList<>();
+ SubnetId consSubnetId = new SubnetId("consSubnetId");
+ consSubnetIds.add(consSubnetId);
+ List<SubnetId> provSubnetIds = new ArrayList<>();
+ SubnetId provSubnetId = new SubnetId("provSubnetId");
+ provSubnetIds.add(provSubnetId);
+ ContractId contractId = new ContractId("contractId");
+ EndpointGroup providerEpg = new EndpointGroupBuilder()
+ .setId(providerEpgId)
+ .build();
+ EndpointGroup consumerEpg = new EndpointGroupBuilder()
+ .setId(consumerEpgId)
+ .build();
+ ExternalImplicitGroup externalImplicitGroup = ExternalImplicitGroup.ProviderEpg;
+
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeLogicalSwitchFromDsIfExists(any(Uuid.class), any(Uuid.class));
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeLogicalRouterFromDsIfExists(any(Uuid.class), any(Uuid.class));
+
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid =
+ mock(CheckedFuture.class);
+ Optional<LogicalNetwork> optLogicalNetwork = mock(Optional.class);
+ Optional<Void> optVoid = mock(Optional.class);
+ when(optLogicalNetwork.isPresent()).thenReturn(true);
+ LogicalNetwork logicalNet =
+ new LogicalNetworkBuilder().setCommunicationLayer(ServiceCommunicationLayer.Layer2)
+ .setConsumerNetwork(
+ new ConsumerNetworkBuilder().setNetworkScopeType(ScopeType.Private)
+ .setGbpSubnetId(consSubnetIds)
+ .setLogicalRouterId(dummyUuid1)
+ .build())
+ .setProviderNetwork(
+ new ProviderNetworkBuilder().setNetworkScopeType(ScopeType.Public)
+ .setGbpSubnetId(provSubnetIds)
+ .setLogicalRouterId(dummyUuid2).build())
+ .setConsumerTenantId(tenantId)
+ .setProviderTenantId(tenantId)
+ .build();
+ when(optLogicalNetwork.get()).thenReturn(logicalNet);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optLogicalNetwork);
+ when(futureVoid.checkedGet()).thenReturn(null);
+
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworkIid(consumerEpg.getId(), tenantId, contractId,
+ providerEpg.getId(), tenantId))).thenReturn(futureLogicalNetwork);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ List<PolicyRuleGroup> prg = new ArrayList<>();
+ PolicyRuleGroup prgElement = new PolicyRuleGroupBuilder()
+ .setContractId(new ContractId("contractId"))
+ .build();
+ prg.add(prgElement);
+ List<PolicyRuleGroupWithEndpointConstraints> prgwec = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraints prgwecElement = new PolicyRuleGroupWithEndpointConstraintsBuilder()
+ .setPolicyRuleGroup(prg)
+ .build();
+ prgwec.add(prgwecElement);
+ ResolvedPolicy oldPolicy = new ResolvedPolicyBuilder()
+ .setConsumerEpgId(consumerEpgId)
+ .setConsumerTenantId(tenantId)
+ .setProviderEpgId(providerEpgId)
+ .setProviderTenantId(tenantId)
+ .setPolicyRuleGroupWithEndpointConstraints(prgwec)
+ .build();
+
+ policyManager.removeLogicalNetwork(oldPolicy);
+
+ }
+
+ @Test
+ public void testRemoveLogicalNetwork_null(){
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.removeLogicalNetwork(null);
+ }
+
+ /*@SuppressWarnings("unchecked")
+ @Test
+ public void testCreateLayer3LogicalNetwork() throws ReadFailedException {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(
+ futureResolvedPolicies);
+
+ MappedSubnet mappedSubnet = new MappedSubnetBuilder()
+ .setFaasSubnetId(dummyUuid1)
+ .build();
+ CheckedFuture<Optional<MappedSubnet>, ReadFailedException> futureMappedSubnet =
+ mock(CheckedFuture.class);
+ Optional<MappedSubnet> optMappedSubnet = mock(Optional.class);
+ when(optMappedSubnet.isPresent()).thenReturn(true);
+ when(optMappedSubnet.get()).thenReturn(mappedSubnet);
+ when(futureMappedSubnet.checkedGet()).thenReturn(optMappedSubnet);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedSubnetIid(tenantId, subnetId))).thenReturn(
+ futureMappedSubnet);
+
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ EndpointGroup consumerEpg = new EndpointGroupBuilder().setId(consumerEpgId).build();
+ EndpointGroup providerEpg = new EndpointGroupBuilder().setId(providerEpgId).build();
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.registerSubnetWithEpg(consumerEpgId, tenantId, consumerSubnet);
+ policyManager.registerSubnetWithEpg(providerEpgId, tenantId, providerSubnet);
+ policyManager.createLayer3LogicalNetwork(consumerEpg, contractId, providerEpg, tenantId,
+ ServiceCommunicationLayer.Layer3, ExternalImplicitGroup.ProviderEpg);
+ }*/
+
+
+
+
+
+ private L3Context makeTestL3Context() {
+ L3ContextBuilder builder = new L3ContextBuilder();
+ builder.setId(l3Context);
+ return builder.build();
+ }
+
+ private L2FloodDomain makeTestL2FloodDomain(String id, L2BridgeDomainId brdgId) {
+ L2FloodDomainBuilder builder = new L2FloodDomainBuilder();
+ builder.setId(new L2FloodDomainId(id));
+ builder.setParent(brdgId);
+ return builder.build();
+ }
+
+ private L2BridgeDomain makeTestBridgeDomain(String id) {
+ L2BridgeDomainBuilder builder = new L2BridgeDomainBuilder();
+ builder.setId(new L2BridgeDomainId(id));
+ builder.setParent(l3Context);
+ return builder.build();
+ }
+
+ private EndpointGroup makeTestEndpointGroup(EndpointGroupId epgId) {
+ EndpointGroupBuilder builder = new EndpointGroupBuilder();
+ builder.setId(epgId);
+ return builder.build();
+ }
+
+ private Subnet makeTestSubnet(SubnetId subnetId, L2FloodDomainId l2FloodDomainId) {
+ SubnetBuilder builder = new SubnetBuilder();
+ builder.setId(subnetId);
+ builder.setParent(l2FloodDomainId);
+ return builder.build();
+
+ }
+
+ private DataObject makeTestResolvedPolicy() {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder();
+ builder.setConsumerEpgId(consumerEpgId);
+ builder.setConsumerTenantId(tenantId);
+ builder.setProviderEpgId(providerEpgId);
+ builder.setProviderTenantId(tenantId);
+ List<PolicyRuleGroupWithEndpointConstraints> pRulesGrpsWEp = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraintsBuilder pRulesGrpWEp = new PolicyRuleGroupWithEndpointConstraintsBuilder();
+ List<PolicyRuleGroup> pRulesGrps = new ArrayList<>();
+ PolicyRuleGroupBuilder pRulesGrp = new PolicyRuleGroupBuilder();
+ pRulesGrp.setContractId(contractId);
+ pRulesGrps.add(pRulesGrp.build());
+ pRulesGrpWEp.setPolicyRuleGroup(pRulesGrps);
+ pRulesGrpsWEp.add(pRulesGrpWEp.build());
+ builder.setPolicyRuleGroupWithEndpointConstraints(pRulesGrpsWEp);
+ return builder.build();
+ }
+
+ private DataObject makeTestResolvedPolicyWithImpExternalEpg() {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder((ResolvedPolicy) makeTestResolvedPolicy());
+ builder.setExternalImplicitGroup(ExternalImplicitGroup.ConsumerEpg);
+ return builder.build();
+ }
+}
/*
* Copyright (c) 2016 Huawei Technologies 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
import com.google.common.util.concurrent.CheckedFuture;
-@PrepareForTest(UlnDatastoreApi.class)
-@RunWith(PowerMockRunner.class)
public class FaasPolicyManagerTest {
private InstanceIdentifier<DataObject> policyId;
change = mock(AsyncDataChangeEvent.class);
policyId = mock(InstanceIdentifier.class);
dataProvider = mock(DataBroker.class);
- PowerMockito.mockStatic(UlnDatastoreApi.class);
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasRendererCovrgTest {
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testConstructor() throws Exception {
+ DataBroker dataProvider = mock(DataBroker.class);
+ EpRendererAugmentationRegistry epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);
+
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ FaasRenderer renderer = new FaasRenderer(dataProvider, epRendererAugmentationRegistry);
+ renderer.close();
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.Gateways;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.GatewaysBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.gateways.Prefixes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.gateways.PrefixesBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(UlnDatastoreApi.class)
+public class FaasSubnetManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Subnet> subnetIid;
+ private FaasSubnetManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private SubnetId subnetId = new SubnetId("subnetId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ dataProvider = mock(DataBroker.class);
+ subnetIid = mock(InstanceIdentifier.class);
+ listener = new FaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(subnetIid);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testOnDataChanged() throws ReadFailedException {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSubnetToDs(any(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet.class));
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeSubnetFromDsIfExists(any(Uuid.class), any(Uuid.class));
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(woTx.submit()).thenReturn(futureVoid);
+
+ CheckedFuture<Optional<MappedSubnet>, ReadFailedException> futureMappedSubnet = mock(CheckedFuture.class);
+ Optional<MappedSubnet> optMappedSubnet = mock(Optional.class);
+ when(optMappedSubnet.isPresent()).thenReturn(true);
+ when(futureMappedSubnet.checkedGet()).thenReturn(optMappedSubnet);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL, FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId)))
+ .thenReturn(futureMappedSubnet);
+ doNothing().when(woTx).put(eq(LogicalDatastoreType.OPERATIONAL),
+ eq(FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId)), any(MappedSubnet.class));
+
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).build();
+ tester.setDataObject(subnetIid, subnet);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testLoadAll() {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSubnetToDs(any(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet.class));
+
+ List<Subnet> subnets = new ArrayList<>();
+ List<MappedSubnet> mpSubnets = new ArrayList<>();
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).build();
+ subnets.add(subnet);
+ MappedSubnet mappedSubnet =
+ new MappedSubnetBuilder().setGbpSubnetId(subnetId).setFaasSubnetId(faasSubnetId).build();
+ mpSubnets.add(mappedSubnet);
+
+ listener.loadAll(subnets, mpSubnets);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testInitSubnetBuilder() {
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ List<Gateways> gatewaysList = new ArrayList<>();
+ List<Prefixes> prefixesList = new ArrayList<>();
+ Prefixes prefixes = new PrefixesBuilder().setPrefix(new IpPrefix(new Ipv4Prefix("10.0.0.0/8"))).build();
+ prefixesList.add(prefixes);
+ Gateways gateways = new GatewaysBuilder().setGateway(new IpAddress(new Ipv4Address("10.0.0.55")))
+ .setPrefixes(prefixesList)
+ .build();
+ gatewaysList.add(gateways);
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).setGateways(gatewaysList).build();
+ listener.initSubnetBuilder(subnet);
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasTenantManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Tenant> tenantIid;
+ private FaasPolicyManager faasPolicyManager;
+ private FaasTenantManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ dataProvider = mock(DataBroker.class);
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ tenantIid = mock(InstanceIdentifier.class);
+ faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ listener = new FaasTenantManagerListener(faasPolicyManager, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(tenantIid);
+
+ }
+
+ @Test
+ public void testOnDataChanged() {
+ Tenant tenant = new TenantBuilder().setId(gbpTenantId).build();
+ tester.setDataObject(tenantIid, tenant);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas.test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class DataChangeListenerTester {
+
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeMock;
+ private DataChangeListener listener;
+
+ private Map<InstanceIdentifier<?>, DataObject> testData;
+ private Set<InstanceIdentifier<?>> removedPaths;
+
+ @SuppressWarnings("unchecked")
+ public DataChangeListenerTester(DataChangeListener listener) {
+ changeMock = mock(AsyncDataChangeEvent.class);
+ testData = new HashMap<>();
+ removedPaths = new HashSet<>();
+
+ this.listener = listener;
+
+ when(changeMock.getCreatedData()).thenReturn(testData);
+ when(changeMock.getOriginalData()).thenReturn(testData);
+ when(changeMock.getUpdatedData()).thenReturn(testData);
+ when(changeMock.getRemovedPaths()).thenReturn(removedPaths);
+ }
+
+ public AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> getChangeMock() {
+ return changeMock;
+ }
+
+ public DataChangeListenerTester setDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
+ testData.clear();
+ return addDataObject(iid, dataObject);
+ }
+
+ public DataChangeListenerTester addDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
+ testData.put(iid, dataObject);
+ return this;
+ }
+
+ public DataChangeListenerTester setRemovedPath(InstanceIdentifier<? extends DataObject> iid){
+ removedPaths.clear();
+ return addRemovedPath(iid);
+ }
+
+ public DataChangeListenerTester addRemovedPath(InstanceIdentifier<? extends DataObject> iid){
+ removedPaths.add(iid);
+ return this;
+ }
+
+ public void callOnDataChanged(){
+ listener.onDataChanged(changeMock);
+ }
+
+}
Code Review / groupbasedpolicy.git / commitdiff