--- /dev/null
+define([], function () {
+ 'use strict';
+
+ angular.module('app.gbp').service('ContractListService', ContractListService);
+
+ ContractListService.$inject = ['Restangular', 'ContractService'];
+
+ function ContractListService(Restangular, ContractService) {
+ /* methods */
+ this.createList = createList;
+
+ function ContractList() {
+ /* properties */
+ this.data = [];
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+
+ /* Implementation */
+ /**
+ * fills ContractList object with data
+ * @param data
+ */
+ function setData(data) {
+ var self = this;
+ data.forEach(function (dataElement) {
+ self.data.push(ContractService.createObject(dataElement));
+ });
+ }
+
+ function get(dataStore) {
+ /* jshint validthis:true */
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one(dataStore).one('policy:tenants')
+ .one('tenant').one('tenant1').one('policy');
+
+ return restObj.get().then(function (data) {
+ if (data.policy.contract) {
+ self.setData(data.policy.contract);
+ }
+ });
+ }
+ }
+
+ function createList() {
+ var obj = new ContractList();
+
+ return obj;
+ }
+ }
+
+ return ContractListService;
+});
define([
-
+ 'app/gbp/contract/contract.service',
+ 'app/gbp/contract/contract-list.service',
], function () {
'use strict';
angular.module('app.gbp').controller('ContractController', ContractController);
- ContractController.$inject = ['$scope'];
+ ContractController.$inject = ['$scope', 'TenantService', 'ContractService', 'ContractListService'];
+
+ function ContractController($scope, TenantService, ContractService, ContractListService) {
+ $scope.tenant = TenantService.createObject();
+ $scope.tenant.get('tenant1');
+ console.log('tenant from CONTRACT CTRL:', $scope.tenant);
+
+ $scope.contract = ContractService.createObject();
+ $scope.contract.get('contract1');
+ console.log('contract from CONTRACT CTRL', $scope.contract);
- function ContractController($scope) {
+ $scope.contracts = ContractListService.createList();
+ $scope.contracts.get('config');
+ console.log('contracts from CONTRACT CTRL', $scope.contracts);
}
});
--- /dev/null
+define([], function () {
+ 'use strict';
+
+ angular.module('app.gbp').service('ContractService', ContractService);
+
+ ContractService.$inject = ['Restangular'];
+
+ function ContractService(Restangular) {
+ /* methods */
+ this.createObject = createObject;
+
+ /**
+ * Contract constructor
+ * @constructor
+ */
+ function Contract() {
+ /* properties */
+ this.data = {};
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+
+ /* Implementation */
+ /**
+ * fills Contract object with data
+ * @param data
+ */
+ function setData(data) {
+ this.data.id = data.id;
+ this.data.description = data.description;
+ this.data.parent = data.parent;
+
+ // TODO: use objects
+ this.data['forwarding-context'] = data['forwarding-context'];
+ this.data.target = data.target;
+ this.data.subject = data.subject;
+ this.data.clause = data.clause;
+ this.data.quality = data.quality;
+ }
+
+ /**
+ * gets one Contract object from Restconf
+ * @param id
+ * @returns {*}
+ */
+ function get(id) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants')
+ .one('tenant').one('tenant1').one('policy').one('contract').one(this.data.id || id);
+
+ return restObj.get().then(function (data) {
+ self.setData(data.contract[0]);
+ });
+ }
+ }
+
+ /**
+ * creates Contract object and fills it with data if available
+ * @param data
+ * @returns {Contract}
+ */
+ function createObject(data) {
+ var obj = new Contract();
+
+ if (data) {
+ obj.setData(data);
+ }
+
+ return obj;
+ }
+ }
+
+ return ContractService;
+});
+<h1>Contrats of tenant: <u>tenant1</u></h1><br /><br />
+<h2><u>contract1:</u></h2><br />
+id: {{contract.data.id}}<br />
+description: {{contract.data.description}}<br />
+parent:{{contract.data.parent}}<br />
+<h2>his containers:</b></h2><br />
+<h3><u>Target object:</u></h3><br />{{contract.data.target}}
+<h3><u>Subject object:</u></h3><br />{{contract.data.subject}}
+<h3><u>Clause object:</u></h3><br />{{contract.data.clause}}
+<h3><u>Quality object:</u></h3><br />{{contract.data.quality}}
+<hr />
+<h2><u>tenant1 contracts list:</u></h2><br />
+<section ng-repeat="contractElement in contracts.data"><h5>{{contractElement.data}}</h5><br /></section>
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.DataChangeListenerTester;
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.EndpointL3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
private InstanceIdentifier<DataObject> endpointId;
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private EndpointManager endpointManager;
- private EndpointManagerListener endpointManagerListener;
+ private DataChangeListenerTester tester;
@SuppressWarnings("unchecked")
@Before
public void init() {
endpointId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
endpointManager = mock(EndpointManager.class);
- endpointId = mock(InstanceIdentifier.class);
DataBroker dataProvider = mock(DataBroker.class);
- endpointManagerListener = new EndpointManagerListener(dataProvider, endpointManager);
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(endpointId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+
+ EndpointManagerListener endpointManagerListener =
+ new EndpointManagerListener(dataProvider, endpointManager);
+ tester = new DataChangeListenerTester(endpointManagerListener);
+ tester.setRemovedPath(endpointId);
}
@Test
public void testOnDataChangeEndpoint() {
DataObject endpoint = mock(Endpoint.class);
+ tester.setDataObject(endpointId, endpoint);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, times(3)).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
@Test
public void testOnDataChangeEndpointL3() {
DataObject endpoint = mock(EndpointL3.class);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
+ tester.setDataObject(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
@Test
public void testOnDataChangeEndpointL3Prefix() {
DataObject endpoint = mock(EndpointL3Prefix.class);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
+ tester.setDataObject(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
-}
\ No newline at end of file
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.eq;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinition;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ActionDefinitionListenerTest {\r
+\r
+ private ActionDefinitionListener listener;\r
+ private DataObjectModification<ActionDefinition> rootNode;\r
+ private Set<DataTreeModification<ActionDefinition>> changes;\r
+\r
+ private DataBroker dataProvider;\r
+\r
+ private InstanceIdentifier<ActionDefinition> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ActionDefinitionListener(dataProvider));\r
+\r
+ ActionDefinitionKey key = mock(ActionDefinitionKey.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class)\r
+ .child(ActionDefinition.class, key)\r
+ .build();\r
+ DataTreeIdentifier<ActionDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ActionDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ActionDefinition def = new ActionDefinitionBuilder().setId(AllowActionDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Write() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedActionDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_SubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedActionDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Delete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.eq;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ClassifierDefinitionListenerTest {\r
+\r
+ private ClassifierDefinitionListener listener;\r
+ private DataObjectModification<ClassifierDefinition> rootNode;\r
+ private Set<DataTreeModification<ClassifierDefinition>> changes;\r
+\r
+ private DataBroker dataProvider;\r
+\r
+ private InstanceIdentifier<ClassifierDefinition> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ClassifierDefinitionListener(dataProvider));\r
+\r
+ ClassifierDefinitionKey key = mock(ClassifierDefinitionKey.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class)\r
+ .child(ClassifierDefinition.class, key)\r
+ .build();\r
+ DataTreeIdentifier<ClassifierDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ClassifierDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ClassifierDefinition def =\r
+ new ClassifierDefinitionBuilder().setId(EtherTypeClassifierDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Write() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.WRITE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedClassifierDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_SubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedClassifierDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Delete() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.DELETE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.ParameterValueList;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\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.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyKey;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ResolvedPolicyClassifierListenerTest {\r
+\r
+ private ResolvedPolicyClassifierListener classifierListener;\r
+ private DataObjectModification<ResolvedPolicy> rootNode;\r
+ private Set<DataTreeModification<ResolvedPolicy>> changes;\r
+\r
+ private InstanceIdentifier<ResolvedPolicy> rootIdentifier;\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = new ClassifierName("classifier1");\r
+ private final SubjectName subjectName = new SubjectName("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ DataBroker dataProvider = mock(DataBroker.class);\r
+ OFStatisticsManager ofStatisticsManager = mock(OFStatisticsManager.class);\r
+\r
+ classifierListener = spy(new ResolvedPolicyClassifierListener(dataProvider, ofStatisticsManager));\r
+\r
+ ResolvedPolicyKey key = mock(ResolvedPolicyKey.class);\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(ResolvedPolicies.class).child(ResolvedPolicy.class, key).build();\r
+ DataTreeIdentifier<ResolvedPolicy> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ResolvedPolicy> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE);\r
+\r
+ Classifier classifier = new ClassifierBuilder().setName(classifierName)\r
+ .setClassifierDefinitionId(IpProtoClassifierDefinition.ID)\r
+ .setParameterValue(parameterValues)\r
+ .build();\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+ when(rootNode.getDataBefore()).thenReturn(rp);\r
+ when(rootNode.getDataAfter()).thenReturn(rp);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onWrite(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.times;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.sflow.values.SflowClientSettings;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class SflowClientSettingsListenerTest {\r
+\r
+ private SflowClientSettingsListener listener;\r
+ private DataObjectModification<SflowClientSettings> rootNode;\r
+ private Set<DataTreeModification<SflowClientSettings>> changes;\r
+\r
+ private InstanceIdentifier<SflowClientSettings> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ DataBroker dataProvider = mock(DataBroker.class);\r
+\r
+ StatisticsManager ofStatisticsManager = mock(StatisticsManager.class);\r
+ ScheduledExecutorService executor = mock(ScheduledExecutorService.class);\r
+ listener = spy(new SflowClientSettingsListener(dataProvider, executor, ofStatisticsManager));\r
+\r
+ SflowClientSettings sflowClientSettings = mock(SflowClientSettings.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(OfOverlayConfig.class).child(SflowClientSettings.class).build();\r
+ DataTreeIdentifier<SflowClientSettings> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<SflowClientSettings> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(sflowClientSettings);\r
+ when(rootNode.getDataAfter()).thenReturn(sflowClientSettings);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onWrite(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ // first call will initialize uninitialized dependencies;\r
+ // second call will call #close on them\r
+ listener.onDataTreeChanged(changes);\r
+ listener.onDataTreeChanged(changes);\r
+ verify(listener, times(2)).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+}\r
import static org.junit.Assert.assertNotNull;\r
import static org.junit.Assert.assertTrue;\r
\r
-import java.util.ArrayList;\r
import java.util.Arrays;\r
import java.util.List;\r
\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.FlowCacheCons;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.IidSflowNameUtil;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.ParameterValueList;\r
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\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.ParameterName;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
FlowCacheCons.Value.BYTES);\r
}\r
\r
- @SuppressWarnings("serial")\r
- private class ParameterValueList extends ArrayList<ParameterValue> {\r
-\r
- ParameterValueList() {\r
- super();\r
- }\r
-\r
- private ParameterValueList addEthertype(Long value) {\r
- this.add(newParameterValue(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, value));\r
- return this;\r
- }\r
-\r
- private ParameterValueList addProto(Long value) {\r
- this.add(newParameterValue(IpProtoClassifierDefinition.PROTO_PARAM, value));\r
- return this;\r
- }\r
-\r
- private ParameterValueList addDstPort(Long value) {\r
- this.add(newParameterValue(L4ClassifierDefinition.DST_PORT_PARAM, value));\r
- return this;\r
- }\r
-\r
- private ParameterValueList addSrcPort(Long value) {\r
- this.add(newParameterValue(L4ClassifierDefinition.SRC_PORT_PARAM, value));\r
- return this;\r
- }\r
-\r
- private ParameterValue newParameterValue(String parameterName, Long intValue) {\r
- return new ParameterValueBuilder().setName(new ParameterName(parameterName)).setIntValue(intValue).build();\r
- }\r
-\r
- }\r
-\r
}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.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.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
+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 DataChangeListenerTester setDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
+ testData.clear();
+ return addDataObject(iid, dataObject);
+ }
+
+ public DataChangeListenerTester addDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
+ testData.put(iid, dataObject);
+ return this;
+ }
+
+ public DataChangeListenerTester setRemovedPath(InstanceIdentifier<DataObject> iid){
+ removedPaths.clear();
+ return addRemovedPath(iid);
+ }
+
+ public DataChangeListenerTester addRemovedPath(InstanceIdentifier<DataObject> iid){
+ removedPaths.add(iid);
+ return this;
+ }
+
+ public void callOnDataChanged(){
+ listener.onDataChanged(changeMock);
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import java.util.ArrayList;
+
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCacheFactoryTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;
+
+public class ParameterValueList extends ArrayList<ParameterValue> {
+
+ public ParameterValueList() {
+ super();
+ }
+
+ public ParameterValueList addEthertype(Long value) {
+ this.add(newParameterValue(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addProto(Long value) {
+ this.add(newParameterValue(IpProtoClassifierDefinition.PROTO_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addDstPort(Long value) {
+ this.add(newParameterValue(L4ClassifierDefinition.DST_PORT_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addSrcPort(Long value) {
+ this.add(newParameterValue(L4ClassifierDefinition.SRC_PORT_PARAM, value));
+ return this;
+ }
+
+ public ParameterValue newParameterValue(String parameterName, Long intValue) {
+ return new ParameterValueBuilder().setName(new ParameterName(parameterName))
+ .setIntValue(intValue).build();
+ }
+
+}
Code Review / groupbasedpolicy.git / commitdiff