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.common.RpcError;
36 import org.opendaylight.yangtools.yang.common.RpcResult;
37 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
38 import org.opendaylight.yangtools.yang.common.Uint32;
41 * Test for {@link GroupUtil}.
43 public class GroupUtilTest {
45 private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId");
46 private static final GroupId DUMMY_GROUP_ID = new GroupId(Uint32.valueOf(42));
47 private static final GroupId DUMMY_GROUP_ID_2 = new GroupId(Uint32.valueOf(43));
48 private static final long GROUP_ACTION_BITMAP =
49 0b00000000000000000000000000000000000001111111111111001100000000001L;
52 public void testBuildGroupPath() {
53 final InstanceIdentifier<Node> nodePath = InstanceIdentifier
55 .child(Node.class, new NodeKey(DUMMY_NODE_ID));
57 final GroupRef groupRef = GroupUtil.buildGroupPath(nodePath, DUMMY_GROUP_ID);
58 final InstanceIdentifier<?> groupRefValue = groupRef.getValue();
59 Assert.assertEquals(DUMMY_NODE_ID, groupRefValue.firstKeyOf(Node.class).getId());
60 Assert.assertEquals(DUMMY_GROUP_ID, groupRefValue.firstKeyOf(Group.class).getGroupId());
64 public void testCreateCumulatingFunction() {
65 final Function<List<RpcResult<String>>, RpcResult<List<BatchFailedGroupsOutput>>> function =
66 GroupUtil.createCumulatingFunction(Lists.newArrayList(createBatchGroup(DUMMY_GROUP_ID),
67 createBatchGroup(DUMMY_GROUP_ID_2)));
69 final RpcResult<List<BatchFailedGroupsOutput>> summary = function.apply(Lists.newArrayList(
70 RpcResultBuilder.success("a").build(),
71 RpcResultBuilder.<String>failed()
72 .withError(RpcError.ErrorType.APPLICATION, "action-failed reason")
75 Assert.assertFalse(summary.isSuccessful());
76 Assert.assertEquals(1, summary.getResult().size());
77 Assert.assertEquals(1, summary.getErrors().size());
78 Assert.assertEquals(DUMMY_GROUP_ID_2, summary.getResult().get(0).getGroupId());
79 Assert.assertEquals(1, summary.getResult().get(0).getBatchOrder().intValue());
82 protected Group createBatchGroup(final GroupId groupId) {
83 return new GroupBuilder().setGroupId(groupId).build();
87 public void testGroupAddTransformFailure() {
88 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
89 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
93 public void testGroupAddTransformFailureSuccess() {
94 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
95 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
99 public void testGroupRemoveTransformFailure() {
100 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
101 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
105 public void testFlowRemoveTransformSuccess() {
106 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
107 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
111 public void testFlowUpdateTransformFailure() {
112 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
113 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
117 public void testFlowUpdateTransformSuccess() {
118 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
119 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
122 private static <T extends BatchGroupOutputListGrouping> void checkBatchSuccessOutcomeTransformation(
123 final RpcResult<T> output) {
124 Assert.assertTrue(output.isSuccessful());
125 Assert.assertEquals(0, output.getResult().nonnullBatchFailedGroupsOutput().size());
126 Assert.assertEquals(0, output.getErrors().size());
129 private static RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
130 return RpcResultBuilder
131 .success(Collections.<BatchFailedGroupsOutput>emptyList())
135 private static RpcResult<List<BatchFailedGroupsOutput>> createBatchOutcomeWithError() {
136 return RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
137 .withError(RpcError.ErrorType.APPLICATION, "ut-flowAddFail")
138 .withResult(Collections.singletonList(new BatchFailedGroupsOutputBuilder()
139 .setGroupId(DUMMY_GROUP_ID)
144 private static <T extends BatchGroupOutputListGrouping> void checkBatchErrorOutcomeTransformation(
145 final RpcResult<T> output) {
146 Assert.assertFalse(output.isSuccessful());
147 Assert.assertEquals(1, output.getResult().nonnullBatchFailedGroupsOutput().size());
148 Assert.assertEquals(DUMMY_GROUP_ID,
149 output.getResult().nonnullBatchFailedGroupsOutput().values().iterator().next().getGroupId());
151 Assert.assertEquals(1, output.getErrors().size());
155 public void testCreateComposingFunction_success_success() {
156 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
157 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
159 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
160 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
161 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
162 Pair.of(addGroupBatchOutput, barrierOutput);
163 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
165 Assert.assertTrue(composite.isSuccessful());
166 Assert.assertEquals(0, composite.getErrors().size());
167 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
171 public void testCreateComposingFunction_failure_success() {
172 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
173 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
175 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
176 final RpcResult<SendBarrierOutput> barrierOutput = RpcResultBuilder.<SendBarrierOutput>success().build();
177 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
178 Pair.of(addGroupBatchOutput, barrierOutput);
179 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
181 Assert.assertFalse(composite.isSuccessful());
182 Assert.assertEquals(1, composite.getErrors().size());
183 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
187 public void testCreateComposingFunction_success_failure() {
188 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
189 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
191 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
192 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
193 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
194 Pair.of(addGroupBatchOutput, barrierOutput);
195 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
197 Assert.assertFalse(composite.isSuccessful());
198 Assert.assertEquals(1, composite.getErrors().size());
199 Assert.assertEquals(0, composite.getResult().nonnullBatchFailedGroupsOutput().size());
203 public void testCreateComposingFunction_failure_failure() {
204 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
205 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
207 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
208 final RpcResult<SendBarrierOutput> barrierOutput = createBarrierFailureOutcome();
209 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>> input =
210 Pair.of(addGroupBatchOutput, barrierOutput);
211 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
213 Assert.assertFalse(composite.isSuccessful());
214 Assert.assertEquals(2, composite.getErrors().size());
215 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
219 public void testExtractGroupActionsSupportBitmap() {
220 ActionType actionSupported = new ActionType(true,true, true, true, true, true, true, true, true, true, true,
221 true, true, true, true, true, true);
222 final List<Uint32> groupActionsSupportBitmap =
223 GroupUtil.extractGroupActionsSupportBitmap(Lists.newArrayList(actionSupported));
224 assertEquals(1, groupActionsSupportBitmap.size());
225 assertEquals(GROUP_ACTION_BITMAP, groupActionsSupportBitmap.get(0).toJava());
228 private static RpcResult<SendBarrierOutput> createBarrierFailureOutcome() {
229 return RpcResultBuilder.<SendBarrierOutput>failed()
230 .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error")
234 private static RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
235 return RpcResultBuilder
236 .success(new AddGroupsBatchOutputBuilder()
237 .setBatchFailedGroupsOutput(Collections.emptyList())
242 private static RpcResult<AddGroupsBatchOutput> createAddGroupsBatchFailureOutcome() {
243 final RpcResult<List<BatchFailedGroupsOutput>> batchOutcomeWithError = createBatchOutcomeWithError();
244 return RpcResultBuilder.<AddGroupsBatchOutput>failed()
245 .withResult(new AddGroupsBatchOutputBuilder()
246 .setBatchFailedGroupsOutput(batchOutcomeWithError.getResult())
248 .withRpcErrors(batchOutcomeWithError.getErrors())