2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.openflowplugin.impl.util;
11 import static org.junit.Assert.assertEquals;
13 import com.google.common.base.Function;
14 import com.google.common.collect.Lists;
15 import java.util.Collections;
16 import java.util.List;
17 import org.apache.commons.lang3.tuple.Pair;
18 import org.junit.Assert;
19 import org.junit.Test;
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput;
21 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupRef;
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutput;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutputBuilder;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.BatchGroupOutputListGrouping;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.output.list.grouping.BatchFailedGroupsOutput;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.output.list.grouping.BatchFailedGroupsOutputBuilder;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ActionType;
35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
36 import org.opendaylight.yangtools.yang.common.RpcError;
37 import org.opendaylight.yangtools.yang.common.RpcResult;
38 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
39 import org.opendaylight.yangtools.yang.common.Uint32;
42 * Test for {@link GroupUtil}.
44 public class GroupUtilTest {
46 private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId");
47 private static final GroupId DUMMY_GROUP_ID = new GroupId(42L);
48 private static final GroupId DUMMY_GROUP_ID_2 = new GroupId(43L);
49 private static final long GROUP_ACTION_BITMAP =
50 0b00000000000000000000000000000000000001111111111111001100000000001L;
53 public void testBuildGroupPath() {
54 final InstanceIdentifier<Node> nodePath = InstanceIdentifier
56 .child(Node.class, new NodeKey(DUMMY_NODE_ID));
58 final GroupRef groupRef = GroupUtil.buildGroupPath(nodePath, DUMMY_GROUP_ID);
59 final InstanceIdentifier<?> groupRefValue = groupRef.getValue();
60 Assert.assertEquals(DUMMY_NODE_ID, groupRefValue.firstKeyOf(Node.class).getId());
61 Assert.assertEquals(DUMMY_GROUP_ID, groupRefValue.firstKeyOf(Group.class).getGroupId());
65 public void testCreateCumulatingFunction() {
66 final Function<List<RpcResult<String>>, RpcResult<List<BatchFailedGroupsOutput>>> function =
67 GroupUtil.createCumulatingFunction(Lists.newArrayList(createBatchGroup(DUMMY_GROUP_ID),
68 createBatchGroup(DUMMY_GROUP_ID_2)));
70 final RpcResult<List<BatchFailedGroupsOutput>> summary = function.apply(Lists.newArrayList(
71 RpcResultBuilder.success("a").build(),
72 RpcResultBuilder.<String>failed()
73 .withError(RpcError.ErrorType.APPLICATION, "action-failed reason")
76 Assert.assertFalse(summary.isSuccessful());
77 Assert.assertEquals(1, summary.getResult().size());
78 Assert.assertEquals(1, summary.getErrors().size());
79 Assert.assertEquals(DUMMY_GROUP_ID_2, summary.getResult().get(0).getGroupId());
80 Assert.assertEquals(1, summary.getResult().get(0).getBatchOrder().intValue());
83 protected Group createBatchGroup(final GroupId groupId) {
84 return new GroupBuilder().setGroupId(groupId).build();
88 public void testGroupAddTransformFailure() {
89 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
90 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
94 public void testGroupAddTransformFailureSuccess() {
95 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
96 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
100 public void testGroupRemoveTransformFailure() {
101 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
102 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
106 public void testFlowRemoveTransformSuccess() {
107 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
108 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
112 public void testFlowUpdateTransformFailure() {
113 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
114 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
118 public void testFlowUpdateTransformSuccess() {
119 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
120 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
123 private static <T extends BatchGroupOutputListGrouping> void checkBatchSuccessOutcomeTransformation(
124 final RpcResult<T> output) {
125 Assert.assertTrue(output.isSuccessful());
126 Assert.assertEquals(0, output.getResult().nonnullBatchFailedGroupsOutput().size());
127 Assert.assertEquals(0, output.getErrors().size());
130 private static RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
131 return RpcResultBuilder
132 .success(Collections.<BatchFailedGroupsOutput>emptyList())
136 private static RpcResult<List<BatchFailedGroupsOutput>> createBatchOutcomeWithError() {
137 return RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
138 .withError(RpcError.ErrorType.APPLICATION, "ut-flowAddFail")
139 .withResult(Collections.singletonList(new BatchFailedGroupsOutputBuilder()
140 .setGroupId(DUMMY_GROUP_ID)
145 private static <T extends BatchGroupOutputListGrouping> void checkBatchErrorOutcomeTransformation(
146 final RpcResult<T> output) {
147 Assert.assertFalse(output.isSuccessful());
148 Assert.assertEquals(1, output.getResult().nonnullBatchFailedGroupsOutput().size());
149 Assert.assertEquals(DUMMY_GROUP_ID,
150 output.getResult().nonnullBatchFailedGroupsOutput().values().iterator().next().getGroupId());
152 Assert.assertEquals(1, output.getErrors().size());
156 public void testCreateComposingFunction_success_success() {
157 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
158 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
160 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
161 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
162 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
163 Pair.of(addGroupBatchOutput, barrierOutput);
164 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
166 Assert.assertTrue(composite.isSuccessful());
167 Assert.assertEquals(0, composite.getErrors().size());
168 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
172 public void testCreateComposingFunction_failure_success() {
173 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
174 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
176 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
177 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
178 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
179 Pair.of(addGroupBatchOutput, barrierOutput);
180 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
182 Assert.assertFalse(composite.isSuccessful());
183 Assert.assertEquals(1, composite.getErrors().size());
184 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
188 public void testCreateComposingFunction_success_failure() {
189 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
190 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
192 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
193 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
194 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
195 Pair.of(addGroupBatchOutput, barrierOutput);
196 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
198 Assert.assertFalse(composite.isSuccessful());
199 Assert.assertEquals(1, composite.getErrors().size());
200 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
204 public void testCreateComposingFunction_failure_failure() {
205 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
206 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
208 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
209 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
210 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
211 Pair.of(addGroupBatchOutput, barrierOutput);
212 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
214 Assert.assertFalse(composite.isSuccessful());
215 Assert.assertEquals(2, composite.getErrors().size());
216 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
220 public void testExtractGroupActionsSupportBitmap() {
221 ActionType actionSupported = new ActionType(true,true, true, true, true, true, true, true, true, true, true,
222 true, true, true, true, true, true);
223 final List<Uint32> groupActionsSupportBitmap =
224 GroupUtil.extractGroupActionsSupportBitmap(Lists.newArrayList(actionSupported));
225 assertEquals(1, groupActionsSupportBitmap.size());
226 assertEquals(GROUP_ACTION_BITMAP, groupActionsSupportBitmap.get(0).toJava());
229 private RpcResult<SendBarrierOutput> createBarrierFailureOutcome() {
230 return RpcResultBuilder.<SendBarrierOutput>failed()
231 .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error")
235 private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
236 return RpcResultBuilder
237 .success(new AddGroupsBatchOutputBuilder()
238 .setBatchFailedGroupsOutput(Collections.emptyList())
243 private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchFailureOutcome() {
244 final RpcResult<List<BatchFailedGroupsOutput>> batchOutcomeWithError = createBatchOutcomeWithError();
245 return RpcResultBuilder.<AddGroupsBatchOutput>failed()
246 .withResult(new AddGroupsBatchOutputBuilder()
247 .setBatchFailedGroupsOutput(batchOutcomeWithError.getResult())
249 .withRpcErrors(batchOutcomeWithError.getErrors())