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
8 package org.opendaylight.openflowplugin.impl.util;
10 import static org.junit.Assert.assertEquals;
12 import com.google.common.base.Function;
13 import com.google.common.collect.Lists;
14 import java.util.Collections;
15 import java.util.List;
16 import org.apache.commons.lang3.tuple.Pair;
17 import org.junit.Assert;
18 import org.junit.Test;
19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput;
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
21 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupRef;
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutput;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutputBuilder;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.BatchGroupOutputListGrouping;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.output.list.grouping.BatchFailedGroupsOutput;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.output.list.grouping.BatchFailedGroupsOutputBuilder;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ActionType;
34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
35 import org.opendaylight.yangtools.yang.binding.util.BindingMap;
36 import org.opendaylight.yangtools.yang.common.ErrorType;
37 import org.opendaylight.yangtools.yang.common.RpcResult;
38 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
39 import org.opendaylight.yangtools.yang.common.Uint16;
40 import org.opendaylight.yangtools.yang.common.Uint32;
43 * Test for {@link GroupUtil}.
45 public class GroupUtilTest {
47 private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId");
48 private static final GroupId DUMMY_GROUP_ID = new GroupId(Uint32.valueOf(42));
49 private static final GroupId DUMMY_GROUP_ID_2 = new GroupId(Uint32.valueOf(43));
50 private static final long GROUP_ACTION_BITMAP =
51 0b00000000000000000000000000000000000001111111111111001100000000001L;
54 public void testBuildGroupPath() {
55 final InstanceIdentifier<Node> nodePath = InstanceIdentifier
57 .child(Node.class, new NodeKey(DUMMY_NODE_ID));
59 final GroupRef groupRef = GroupUtil.buildGroupPath(nodePath, DUMMY_GROUP_ID);
60 final InstanceIdentifier<?> groupRefValue = groupRef.getValue();
61 Assert.assertEquals(DUMMY_NODE_ID, groupRefValue.firstKeyOf(Node.class).getId());
62 Assert.assertEquals(DUMMY_GROUP_ID, groupRefValue.firstKeyOf(Group.class).getGroupId());
66 public void testCreateCumulatingFunction() {
67 final Function<List<RpcResult<String>>, RpcResult<List<BatchFailedGroupsOutput>>> function =
68 GroupUtil.createCumulatingFunction(Lists.newArrayList(createBatchGroup(DUMMY_GROUP_ID),
69 createBatchGroup(DUMMY_GROUP_ID_2)));
71 final RpcResult<List<BatchFailedGroupsOutput>> summary = function.apply(Lists.newArrayList(
72 RpcResultBuilder.success("a").build(),
73 RpcResultBuilder.<String>failed()
74 .withError(ErrorType.APPLICATION, "action-failed reason")
77 Assert.assertFalse(summary.isSuccessful());
78 Assert.assertEquals(1, summary.getResult().size());
79 Assert.assertEquals(1, summary.getErrors().size());
80 Assert.assertEquals(DUMMY_GROUP_ID_2, summary.getResult().get(0).getGroupId());
81 Assert.assertEquals(1, summary.getResult().get(0).getBatchOrder().intValue());
84 protected Group createBatchGroup(final GroupId groupId) {
85 return new GroupBuilder().setGroupId(groupId).build();
89 public void testGroupAddTransformFailure() {
90 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
91 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
95 public void testGroupAddTransformFailureSuccess() {
96 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
97 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
101 public void testGroupRemoveTransformFailure() {
102 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
103 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
107 public void testFlowRemoveTransformSuccess() {
108 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
109 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
113 public void testFlowUpdateTransformFailure() {
114 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
115 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
119 public void testFlowUpdateTransformSuccess() {
120 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
121 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
124 private static <T extends BatchGroupOutputListGrouping> void checkBatchSuccessOutcomeTransformation(
125 final RpcResult<T> output) {
126 Assert.assertTrue(output.isSuccessful());
127 Assert.assertEquals(0, output.getResult().nonnullBatchFailedGroupsOutput().size());
128 Assert.assertEquals(0, output.getErrors().size());
131 private static RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
132 return RpcResultBuilder
133 .success(Collections.<BatchFailedGroupsOutput>emptyList())
137 private static RpcResult<List<BatchFailedGroupsOutput>> createBatchOutcomeWithError() {
138 return RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
139 .withError(ErrorType.APPLICATION, "ut-flowAddFail")
140 .withResult(List.of(new BatchFailedGroupsOutputBuilder()
141 .setBatchOrder(Uint16.ZERO)
142 .setGroupId(DUMMY_GROUP_ID)
147 private static <T extends BatchGroupOutputListGrouping> void checkBatchErrorOutcomeTransformation(
148 final RpcResult<T> output) {
149 Assert.assertFalse(output.isSuccessful());
150 Assert.assertEquals(1, output.getResult().nonnullBatchFailedGroupsOutput().size());
151 Assert.assertEquals(DUMMY_GROUP_ID,
152 output.getResult().nonnullBatchFailedGroupsOutput().values().iterator().next().getGroupId());
154 Assert.assertEquals(1, output.getErrors().size());
158 public void testCreateComposingFunction_success_success() {
159 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
160 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
162 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
163 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
164 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
165 Pair.of(addGroupBatchOutput, barrierOutput);
166 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
168 Assert.assertTrue(composite.isSuccessful());
169 Assert.assertEquals(0, composite.getErrors().size());
170 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
174 public void testCreateComposingFunction_failure_success() {
175 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
176 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
178 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
179 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
180 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
181 Pair.of(addGroupBatchOutput, barrierOutput);
182 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
184 Assert.assertFalse(composite.isSuccessful());
185 Assert.assertEquals(1, composite.getErrors().size());
186 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
190 public void testCreateComposingFunction_success_failure() {
191 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
192 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
194 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
195 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
196 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
197 Pair.of(addGroupBatchOutput, barrierOutput);
198 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
200 Assert.assertFalse(composite.isSuccessful());
201 Assert.assertEquals(1, composite.getErrors().size());
202 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
206 public void testCreateComposingFunction_failure_failure() {
207 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
208 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
210 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
211 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
212 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
213 Pair.of(addGroupBatchOutput, barrierOutput);
214 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
216 Assert.assertFalse(composite.isSuccessful());
217 Assert.assertEquals(2, composite.getErrors().size());
218 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
222 public void testExtractGroupActionsSupportBitmap() {
223 ActionType actionSupported = new ActionType(true,true, true, true, true, true, true, true, true, true, true,
224 true, true, true, true, true, true);
225 final List<Uint32> groupActionsSupportBitmap =
226 GroupUtil.extractGroupActionsSupportBitmap(Lists.newArrayList(actionSupported));
227 assertEquals(1, groupActionsSupportBitmap.size());
228 assertEquals(GROUP_ACTION_BITMAP, groupActionsSupportBitmap.get(0).toJava());
231 private static RpcResult<SendBarrierOutput> createBarrierFailureOutcome() {
232 return RpcResultBuilder.<SendBarrierOutput>failed()
233 .withError(ErrorType.APPLICATION, "ut-barrier-error")
237 private static RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
238 return RpcResultBuilder
239 .success(new AddGroupsBatchOutputBuilder()
240 .setBatchFailedGroupsOutput(Collections.emptyMap())
245 private static RpcResult<AddGroupsBatchOutput> createAddGroupsBatchFailureOutcome() {
246 final RpcResult<List<BatchFailedGroupsOutput>> batchOutcomeWithError = createBatchOutcomeWithError();
247 return RpcResultBuilder.<AddGroupsBatchOutput>failed()
248 .withResult(new AddGroupsBatchOutputBuilder()
249 .setBatchFailedGroupsOutput(BindingMap.ordered(batchOutcomeWithError.getResult()))
251 .withRpcErrors(batchOutcomeWithError.getErrors())