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 <T extends BatchGroupOutputListGrouping> void checkBatchSuccessOutcomeTransformation(
124 final RpcResult<T> output) {
125 Assert.assertTrue(output.isSuccessful());
126 Assert.assertEquals(0, output.getResult().getBatchFailedGroupsOutput().size());
127 Assert.assertEquals(0, output.getErrors().size());
130 private RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
131 return RpcResultBuilder
132 .success(Collections.<BatchFailedGroupsOutput>emptyList())
136 private 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 <T extends BatchGroupOutputListGrouping> void checkBatchErrorOutcomeTransformation(
146 final RpcResult<T> output) {
147 Assert.assertFalse(output.isSuccessful());
148 Assert.assertEquals(1, output.getResult().getBatchFailedGroupsOutput().size());
149 Assert.assertEquals(DUMMY_GROUP_ID, output.getResult().getBatchFailedGroupsOutput().get(0).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().getBatchFailedGroupsOutput().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().getBatchFailedGroupsOutput().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 RpcResult<SendBarrierOutput> createBarrierFailureOutcome() {
229 return RpcResultBuilder.<SendBarrierOutput>failed()
230 .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error")
234 private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
235 return RpcResultBuilder
236 .success(new AddGroupsBatchOutputBuilder()
237 .setBatchFailedGroupsOutput(Collections.emptyList())
242 private 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())