From: Konstantin Blagov Date: Thu, 19 May 2016 08:58:06 +0000 (+0200) Subject: Tests for iovisor.sf X-Git-Tag: release/boron~161^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=8ee74e9df25a101c0f64b78a44f92411cb36f74e;p=groupbasedpolicy.git Tests for iovisor.sf Change-Id: I0ed495c712dca33070deda229a318fa1f6722339 Signed-off-by: Konstantin Blagov --- diff --git a/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResult.java b/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResult.java old mode 100644 new mode 100755 index cb4a37977..7d5dd5ac3 --- a/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResult.java +++ b/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResult.java @@ -14,6 +14,7 @@ import com.google.common.base.Preconditions; public class ClassificationResult { + static final String DEFAULT_ERROR_MESSAGE = ""; private final String errorMessage; private final boolean isSuccessful; @@ -29,7 +30,7 @@ public class ClassificationResult { * @param matches cannot be {@code null} */ public ClassificationResult(List matches) { - errorMessage = ""; + errorMessage = DEFAULT_ERROR_MESSAGE; this.isSuccessful = true; } diff --git a/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4Classifier.java b/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4Classifier.java index 7bb668e34..6a78cfda4 100755 --- a/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4Classifier.java +++ b/renderers/iovisor/src/main/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4Classifier.java @@ -11,12 +11,12 @@ package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; import java.util.List; import java.util.Map; +import com.google.common.collect.ImmutableList; import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId; 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.definitions.ClassifierDefinition; 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.parameter.value.RangeValue; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.RangeBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues; @@ -26,13 +26,15 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.r import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValue; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValueBuilder; -import com.google.common.collect.ImmutableList; - /** * Match against TCP or UDP, and source and/or destination ports */ public class L4Classifier extends Classifier { + static final String EXC_MSG_PARAM_VALUE_NOT_SPECIFIED = "Value of parameter not specified: "; + static final String EXC_MSG_MUT_EXCLUSIVE_PARAMS = "Mutually exclusive parameters: "; + static final String EXC_MSG_RANGE_VALUE_MISMATCH = "Range value mismatch: "; + protected L4Classifier(Classifier parent) { super(parent); } @@ -87,15 +89,11 @@ public class L4Classifier extends Classifier { if (params.get(portParam) != null) { StringBuilder paramLog = new StringBuilder(); if (params.get(portParam).getIntValue() == null) { - paramLog.append("Value of ").append(portParam).append(" parameter is not specified."); + paramLog.append(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED).append(portParam); throw new IllegalArgumentException(paramLog.toString()); } if (params.get(portRangeParam) != null) { - paramLog.append("Source port parameters ") - .append(portParam) - .append(" and ") - .append(portRangeParam) - .append(" are mutually exclusive."); + paramLog.append(EXC_MSG_MUT_EXCLUSIVE_PARAMS).append(portParam).append(" and ").append(portRangeParam); throw new IllegalArgumentException(paramLog.toString()); } } @@ -103,18 +101,14 @@ public class L4Classifier extends Classifier { private void validateRange(Map params, String portRangeParam) { if (params.get(portRangeParam) != null) { - validateRangeValue(params.get(portRangeParam).getRangeValue()); - } - } - - private void validateRangeValue(RangeValue rangeValueParam) { - if (rangeValueParam == null) { - throw new IllegalArgumentException("Range parameter is specifiet but value is not present."); - } - final Long min = rangeValueParam.getMin(); - final Long max = rangeValueParam.getMax(); - if (min > max) { - throw new IllegalArgumentException("Range value mismatch. " + min + " is greater than MAX " + max + "."); + if (params.get(portRangeParam).getRangeValue() == null) { + throw new IllegalArgumentException(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED + portRangeParam); + } + Long min = params.get(portRangeParam).getRangeValue().getMin(); + Long max = params.get(portRangeParam).getRangeValue().getMax(); + if (min > max) { + throw new IllegalArgumentException(EXC_MSG_RANGE_VALUE_MISMATCH + min + ">" + max); + } } } diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ActionDefinitionListenerTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ActionDefinitionListenerTest.java new file mode 100755 index 000000000..d418eedf0 --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ActionDefinitionListenerTest.java @@ -0,0 +1,101 @@ +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +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.Set; + +import com.google.common.collect.ImmutableSet; +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.DataObjectModification; +import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; +import org.opendaylight.controller.md.sal.binding.api.DataTreeModification; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class ActionDefinitionListenerTest { + + private ActionDefinitionListener listener; + private DataObjectModification rootNode; + private Set> changes; + + private InstanceIdentifier rootIdentifier; + private DataBroker dataProvider; + + @SuppressWarnings("unchecked") + @Before + public void init() { + dataProvider = mock(DataBroker.class); + + listener = spy(new ActionDefinitionListener(dataProvider)); + + ActionDefinitionKey key = mock(ActionDefinitionKey.class); + rootNode = mock(DataObjectModification.class); + rootIdentifier = + InstanceIdentifier.builder(SubjectFeatureDefinitions.class).child(ActionDefinition.class, key).build(); + DataTreeIdentifier rootPath = + new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier); + + DataTreeModification change = mock(DataTreeModification.class); + + when(change.getRootNode()).thenReturn(rootNode); + when(change.getRootPath()).thenReturn(rootPath); + + changes = ImmutableSet.of(change); + + ActionDefinition def = new ActionDefinitionBuilder().setId(AllowActionDefinition.ID).build(); + + when(rootNode.getDataBefore()).thenReturn(def); + when(rootNode.getDataAfter()).thenReturn(def); + } + + @Test + public void testOnWrite() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onSubtreeModified(rootNode, rootIdentifier); + } + + @Test + public void testOnDelete() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onDelete(rootNode, rootIdentifier); + } + + @Test + public void testOnSubtreeModified() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onSubtreeModified(rootNode, rootIdentifier); + } + + private WriteTransaction resetTransaction() { + WriteTransaction wt = mock(WriteTransaction.class); + CheckedFuture checkedFuture = mock(CheckedFuture.class); + when(wt.submit()).thenReturn(checkedFuture); + when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt); + return wt; + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/AllowActionTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/AllowActionTest.java new file mode 100755 index 000000000..2ac13317e --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/AllowActionTest.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.ValidationResult; +import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstanceBuilder; + +public class AllowActionTest { + + AllowAction action; + + @Before + public void init() { + action = new AllowAction(); + } + + @Test + public void testGetId() { + assertEquals(action.getId(), AllowActionDefinition.ID); + } + + @Test + public void testGetActionDef() { + assertEquals(action.getActionDef(), AllowActionDefinition.DEFINITION); + } + + @Test + public void testGetSupportedParameterValues() { + assertTrue(action.getSupportedParameterValues().isEmpty()); + } + + @Test + public void testValidate() { + ActionInstance actionInstance = new ActionInstanceBuilder().build(); + ValidationResult result = action.validate(actionInstance); + assertTrue(result.isValid()); + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResultTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResultTest.java new file mode 100755 index 000000000..74646facb --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassificationResultTest.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; + +public class ClassificationResultTest { + + private static final String ERROR_MESSAGE = "error message"; + private ClassificationResult resultOk; + private ClassificationResult resultError; + + @Before + public void init() { + List list = new ArrayList<>(); + list.add("string"); + resultOk = new ClassificationResult(list); + resultError = new ClassificationResult(ERROR_MESSAGE); + } + + @Test + public void testConstructor_Result() { + assertTrue(resultOk.isSuccessfull()); + } + + @Test + public void testConstructor_ErrorMsg() { + assertFalse(resultError.isSuccessfull()); + } + + @Test + public void testGetErrorMessage() { + assertEquals(resultOk.getErrorMessage(), ClassificationResult.DEFAULT_ERROR_MESSAGE); + assertEquals(resultError.getErrorMessage(), ERROR_MESSAGE); + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassifierDefinitionListenerTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassifierDefinitionListenerTest.java new file mode 100755 index 000000000..eb02ac9d4 --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ClassifierDefinitionListenerTest.java @@ -0,0 +1,102 @@ +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +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.Set; + +import com.google.common.collect.ImmutableSet; +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.DataObjectModification; +import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; +import org.opendaylight.controller.md.sal.binding.api.DataTreeModification; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class ClassifierDefinitionListenerTest { + + private ClassifierDefinitionListener listener; + private DataObjectModification rootNode; + private Set> changes; + + private InstanceIdentifier rootIdentifier; + private DataBroker dataProvider; + + @SuppressWarnings("unchecked") + @Before + public void init() { + dataProvider = mock(DataBroker.class); + + listener = spy(new ClassifierDefinitionListener(dataProvider)); + + ClassifierDefinitionKey key = mock(ClassifierDefinitionKey.class); + rootNode = mock(DataObjectModification.class); + rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class) + .child(ClassifierDefinition.class, key) + .build(); + DataTreeIdentifier rootPath = + new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier); + + DataTreeModification change = mock(DataTreeModification.class); + + when(change.getRootNode()).thenReturn(rootNode); + when(change.getRootPath()).thenReturn(rootPath); + + changes = ImmutableSet.of(change); + + ClassifierDefinition def = new ClassifierDefinitionBuilder().setId(EtherTypeClassifierDefinition.ID).build(); + + when(rootNode.getDataBefore()).thenReturn(def); + when(rootNode.getDataAfter()).thenReturn(def); + } + + @Test + public void testOnWrite() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onSubtreeModified(rootNode, rootIdentifier); + } + + @Test + public void testOnDelete() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onDelete(rootNode, rootIdentifier); + } + + @Test + public void testOnSubtreeModified() { + when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED); + WriteTransaction wt = resetTransaction(); + + listener.onDataTreeChanged(changes); + + verify(listener).onSubtreeModified(rootNode, rootIdentifier); + } + + private WriteTransaction resetTransaction() { + WriteTransaction wt = mock(WriteTransaction.class); + CheckedFuture checkedFuture = mock(CheckedFuture.class); + when(wt.submit()).thenReturn(checkedFuture); + when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt); + return wt; + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/EtherTypeClassifierTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/EtherTypeClassifierTest.java new file mode 100755 index 000000000..8720c2fbe --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/EtherTypeClassifierTest.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition; +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; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues; + +public class EtherTypeClassifierTest { + + @Test + public void testGetId() { + assertEquals(EtherTypeClassifierDefinition.ID, Classifier.ETHER_TYPE_CL.getId()); + } + + @Test + public void testGetClassifierDefinition() { + assertEquals(EtherTypeClassifierDefinition.DEFINITION, Classifier.ETHER_TYPE_CL.getClassifierDefinition()); + } + + @Test + public void testGetSupportedParameterValues() { + List valuesList = Classifier.ETHER_TYPE_CL.getSupportedParameterValues(); + assertEquals(1, valuesList.size()); + + SupportedParameterValues values = valuesList.get(0); + assertNotNull(values); + assertEquals(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, values.getParameterName().getValue()); + ParameterType pt = values.getParameterType(); + assertTrue(pt instanceof Int); + } + + @Test + public void testCheckPresenceOfRequiredParams() { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.ARP_VALUE).build(); + params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv); + + try { + Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params); + } catch (IllegalArgumentException e) { + fail("Required parameter missing"); + } + } + + @Test(expected = IllegalArgumentException.class) + public void testCheckPresenceOfRequiredParams_noParam() { + Map params = new HashMap<>(); + + Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params); + } + + @Test(expected = IllegalArgumentException.class) + public void testCheckPresenceOfRequiredParams_nullValue() { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().build(); + params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv); + + Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testGetParent() { + assertNull(Classifier.ETHER_TYPE_CL.getParent()); + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/IpProtoClassifierTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/IpProtoClassifierTest.java new file mode 100755 index 000000000..57734e1fb --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/IpProtoClassifierTest.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition; +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; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues; + +public class IpProtoClassifierTest { + + @Test + public void testGetId() { + assertEquals(IpProtoClassifierDefinition.ID, Classifier.IP_PROTO_CL.getId()); + } + + @Test + public void testGetClassifierDefinition() { + assertEquals(IpProtoClassifierDefinition.DEFINITION, Classifier.IP_PROTO_CL.getClassifierDefinition()); + } + + @Test + public void testGetSupportedParameterValues() { + List valuesList = Classifier.IP_PROTO_CL.getSupportedParameterValues(); + assertEquals(1, valuesList.size()); + + SupportedParameterValues values = valuesList.get(0); + assertNotNull(values); + assertEquals(IpProtoClassifierDefinition.PROTO_PARAM, values.getParameterName().getValue()); + ParameterType pt = values.getParameterType(); + assertTrue(pt instanceof Int); + } + + @Test + public void testCheckPresenceOfRequiredParams() { + Map params = prepareParams(IpProtoClassifierDefinition.UDP_VALUE); + + try { + Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params); + } catch (IllegalArgumentException e) { + fail("Required parameter missing"); + } + } + + @Test(expected = IllegalArgumentException.class) + public void testCheckPresenceOfRequiredParams_noParam() { + Map params = new HashMap<>(); + + Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params); + } + + @Test(expected = IllegalArgumentException.class) + public void testCheckPresenceOfRequiredParams_nullValue() { + Map params = prepareParams_nullValue(); + + Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testGetIpProtoValue() { + Long expected = IpProtoClassifierDefinition.UDP_VALUE; + + assertEquals(expected, IpProtoClassifier.getIpProtoValue(prepareParams(expected))); + } + + @Test + public void testGetIpProtoValue_badParams() { + Map params = prepareParams_nullValue(); + + assertNull(IpProtoClassifier.getIpProtoValue(params)); + assertNull(IpProtoClassifier.getIpProtoValue(new HashMap())); + assertNull(IpProtoClassifier.getIpProtoValue(null)); + } + + @Test + public void testGetParent() { + assertEquals(Classifier.IP_PROTO_CL.getParent(), Classifier.ETHER_TYPE_CL); + } + + private Map prepareParams(Long intValue) { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().setIntValue(intValue).build(); + params.put(IpProtoClassifierDefinition.PROTO_PARAM, pv); + return params; + } + + private Map prepareParams_nullValue() { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().build(); + params.put(IpProtoClassifierDefinition.PROTO_PARAM, pv); + return params; + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4ClassifierTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4ClassifierTest.java new file mode 100755 index 000000000..14ddba629 --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/L4ClassifierTest.java @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition; +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; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.parameter.value.RangeValueBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues; + +public class L4ClassifierTest { + + private ParameterValue pvSrcPort80; + private ParameterValue pvDstPort80; + private ParameterValue pvDstPort_null; + private ParameterValue pvSrcRange81_82; + private ParameterValue pvDstRange81_82; + private ParameterValue pvDstRange82_81; + private ParameterValue pvDstRange_null; + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Before + public void init() { + pvSrcPort80 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).setIntValue(80L).build(); + pvDstPort80 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).setIntValue(80L).build(); + pvDstPort_null = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build(); + pvSrcRange81_82 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build()) + .build(); + pvDstRange81_82 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build()) + .build(); + pvDstRange82_81 = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + .setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build()) + .build(); + pvDstRange_null = new ParameterValueBuilder().setName( + new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM)) + //.setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build()) + .build(); + } + + @Test + public void testGetId() { + assertEquals(L4ClassifierDefinition.ID, Classifier.L4_CL.getId()); + } + + @Test + public void testGetClassifierDefinition() { + assertEquals(L4ClassifierDefinition.DEFINITION, Classifier.L4_CL.getClassifierDefinition()); + } + + @Test + public void testGetSupportedParameterValues() { + List valuesList = Classifier.L4_CL.getSupportedParameterValues(); + assertEquals(4, valuesList.size()); + + SupportedParameterValues values = valuesList.get(0); + assertNotNull(values); + assertEquals(L4ClassifierDefinition.SRC_PORT_PARAM, values.getParameterName().getValue()); + ParameterType pt = values.getParameterType(); + assertTrue(pt instanceof Int); + } + + @Test + public void testCheckPresenceOfRequiredParams_Empty() throws Exception { + // TODO check: sending empty map is ok? + Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap()); + } + + @Test + public void testCheckPresenceOfRequiredParams_SinglePorts() throws Exception { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort80); + + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_PortRanges() throws Exception { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange81_82); + + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_DstPortNull() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort_null); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_DstRangeNull() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange_null); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_ParamConflict() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_MUT_EXCLUSIVE_PARAMS); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_RangeInverted() throws IllegalArgumentException { + Map params = new HashMap<>(); + params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80); + params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange82_81); + + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage(L4Classifier.EXC_MSG_RANGE_VALUE_MISMATCH); + Classifier.L4_CL.checkPresenceOfRequiredParams(params); + } + + @Test + public void testCheckPresenceOfRequiredParams_emptyParams() { + + Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap()); + } + + @Test + public void testGetParent() { + assertEquals(Classifier.L4_CL.getParent(), Classifier.IP_PROTO_CL); + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ParamDerivatorTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ParamDerivatorTest.java new file mode 100755 index 000000000..5884bb471 --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/ParamDerivatorTest.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition; +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 ParamDerivatorTest { + + private ParamDerivator derivator = ParamDerivator.ETHER_TYPE_DERIVATOR; + + @Test + public void testDeriveParameter_noDerivation() { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.IPv4_VALUE).build(); + params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv); + + List> result = derivator.deriveParameter(params); + + assertEquals(1, result.size()); + assertEquals(params, result.get(0)); + } + + @Test + public void testDeriveParameter_withDerivation() { + Map params = new HashMap<>(); + ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.IPv4_VALUE).build(); + params.put("dummy key", pv); + + List> derivedParams = derivator.deriveParameter(params); + + assertEquals(2, derivedParams.size()); + + Map ipv4Params = derivedParams.get(0); + Map ipv6Params = derivedParams.get(1); + + assertTrue(ipv4Params.containsKey(EtherTypeClassifierDefinition.ETHERTYPE_PARAM)); + assertTrue(ipv6Params.containsKey(EtherTypeClassifierDefinition.ETHERTYPE_PARAM)); + } + +} diff --git a/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/SubjectFeaturesTest.java b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/SubjectFeaturesTest.java new file mode 100755 index 000000000..743ca9e8a --- /dev/null +++ b/renderers/iovisor/src/test/java/org/opendaylight/groupbasedpolicy/renderer/iovisor/sf/SubjectFeaturesTest.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2016 Cisco Systems, Inc. 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 + */ + +package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf; + +import static junit.framework.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import org.junit.Assert; +import org.junit.Test; +import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition; +import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition; +import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition; +import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition; + +public class SubjectFeaturesTest { + + @Test + public void testGetClassifier() { + assertEquals(Classifier.ETHER_TYPE_CL, SubjectFeatures.getClassifier(EtherTypeClassifierDefinition.ID)); + assertEquals(Classifier.IP_PROTO_CL, SubjectFeatures.getClassifier(IpProtoClassifierDefinition.ID)); + assertEquals(Classifier.L4_CL, SubjectFeatures.getClassifier(L4ClassifierDefinition.ID)); + } + + @Test + public void testGetActions() { + assertNotNull(SubjectFeatures.getActions()); + } + + @Test + public void testGetAction() { + Assert.assertEquals(AllowActionDefinition.DEFINITION, + SubjectFeatures.getAction(AllowActionDefinition.ID).getActionDef()); + } + +}