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.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;
40 * Test for {@link GroupUtil}.
42 public class GroupUtilTest {
44 private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId");
45 private static final GroupId DUMMY_GROUP_ID = new GroupId(42L);
46 private static final GroupId DUMMY_GROUP_ID_2 = new GroupId(43L);
47 private static final Long GROUP_ACTION_BITMAP =
48 0b00000000000000000000000000000000000001111111111111001100000000001L;
51 public void testBuildGroupPath() throws Exception {
52 final InstanceIdentifier<Node> nodePath = InstanceIdentifier
54 .child(Node.class, new NodeKey(DUMMY_NODE_ID));
56 final GroupRef groupRef = GroupUtil.buildGroupPath(nodePath, DUMMY_GROUP_ID);
57 final InstanceIdentifier<?> groupRefValue = groupRef.getValue();
58 Assert.assertEquals(DUMMY_NODE_ID, groupRefValue.firstKeyOf(Node.class).getId());
59 Assert.assertEquals(DUMMY_GROUP_ID, groupRefValue.firstKeyOf(Group.class).getGroupId());
63 public void testCreateCumulatingFunction() throws Exception {
64 final Function<List<RpcResult<String>>, RpcResult<List<BatchFailedGroupsOutput>>> function =
65 GroupUtil.createCumulatingFunction(Lists.newArrayList(createBatchGroup(DUMMY_GROUP_ID),
66 createBatchGroup(DUMMY_GROUP_ID_2)));
68 final RpcResult<List<BatchFailedGroupsOutput>> summary = function.apply(Lists.newArrayList(
69 RpcResultBuilder.success("a").build(),
70 RpcResultBuilder.<String>failed()
71 .withError(RpcError.ErrorType.APPLICATION, "action-failed reason")
74 Assert.assertFalse(summary.isSuccessful());
75 Assert.assertEquals(1, summary.getResult().size());
76 Assert.assertEquals(1, summary.getErrors().size());
77 Assert.assertEquals(DUMMY_GROUP_ID_2, summary.getResult().get(0).getGroupId());
78 Assert.assertEquals(1, summary.getResult().get(0).getBatchOrder().intValue());
81 protected Group createBatchGroup(final GroupId groupId) {
82 return new GroupBuilder().setGroupId(groupId).build();
86 public void testGroupAddTransformFailure() throws Exception {
87 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
88 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
92 public void testGroupAddTransformFailureSuccess() throws Exception {
93 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
94 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
98 public void testGroupRemoveTransformFailure() throws Exception {
99 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
100 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
104 public void testFlowRemoveTransformSuccess() throws Exception {
105 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
106 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
110 public void testFlowUpdateTransformFailure() throws Exception {
111 final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
112 checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
116 public void testFlowUpdateTransformSuccess() throws Exception {
117 final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
118 checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
121 private <T extends BatchGroupOutputListGrouping> void checkBatchSuccessOutcomeTransformation(
122 final RpcResult<T> output) {
123 Assert.assertTrue(output.isSuccessful());
124 Assert.assertEquals(0, output.getResult().getBatchFailedGroupsOutput().size());
125 Assert.assertEquals(0, output.getErrors().size());
128 private RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
129 return RpcResultBuilder
130 .<List<BatchFailedGroupsOutput>>success(Collections.<BatchFailedGroupsOutput>emptyList())
134 private RpcResult<List<BatchFailedGroupsOutput>> createBatchOutcomeWithError() {
135 return RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
136 .withError(RpcError.ErrorType.APPLICATION, "ut-flowAddFail")
137 .withResult(Collections.singletonList(new BatchFailedGroupsOutputBuilder()
138 .setGroupId(DUMMY_GROUP_ID)
143 private <T extends BatchGroupOutputListGrouping> void checkBatchErrorOutcomeTransformation(
144 final RpcResult<T> output) {
145 Assert.assertFalse(output.isSuccessful());
146 Assert.assertEquals(1, output.getResult().getBatchFailedGroupsOutput().size());
147 Assert.assertEquals(DUMMY_GROUP_ID, output.getResult().getBatchFailedGroupsOutput().get(0).getGroupId());
149 Assert.assertEquals(1, output.getErrors().size());
153 public void testCreateComposingFunction_success_success() throws Exception {
154 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>>, RpcResult<AddGroupsBatchOutput>>
155 compositeFunction = GroupUtil.createComposingFunction();
157 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
158 final RpcResult<Void> barrierOutput = RpcResultBuilder.<Void>success().build();
159 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>> input =
160 Pair.of(addGroupBatchOutput, barrierOutput);
161 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
163 Assert.assertTrue(composite.isSuccessful());
164 Assert.assertEquals(0, composite.getErrors().size());
165 Assert.assertEquals(0, composite.getResult().getBatchFailedGroupsOutput().size());
169 public void testCreateComposingFunction_failure_success() throws Exception {
170 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>>, RpcResult<AddGroupsBatchOutput>>
171 compositeFunction = GroupUtil.createComposingFunction();
173 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
174 final RpcResult<Void> barrierOutput = RpcResultBuilder.<Void>success().build();
175 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>> input =
176 Pair.of(addGroupBatchOutput, barrierOutput);
177 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
179 Assert.assertFalse(composite.isSuccessful());
180 Assert.assertEquals(1, composite.getErrors().size());
181 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
185 public void testCreateComposingFunction_success_failure() throws Exception {
186 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>>, RpcResult<AddGroupsBatchOutput>>
187 compositeFunction = GroupUtil.createComposingFunction();
189 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchSuccessOutput();
190 final RpcResult<Void> barrierOutput = createBarrierFailureOutcome();
191 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>> input =
192 Pair.of(addGroupBatchOutput, barrierOutput);
193 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
195 Assert.assertFalse(composite.isSuccessful());
196 Assert.assertEquals(1, composite.getErrors().size());
197 Assert.assertEquals(0, composite.getResult().getBatchFailedGroupsOutput().size());
201 public void testCreateComposingFunction_failure_failure() throws Exception {
202 final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>>, RpcResult<AddGroupsBatchOutput>>
203 compositeFunction = GroupUtil.createComposingFunction();
205 final RpcResult<AddGroupsBatchOutput> addGroupBatchOutput = createAddGroupsBatchFailureOutcome();
206 final RpcResult<Void> barrierOutput = createBarrierFailureOutcome();
207 final Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<Void>> input =
208 Pair.of(addGroupBatchOutput, barrierOutput);
209 final RpcResult<AddGroupsBatchOutput> composite = compositeFunction.apply(input);
211 Assert.assertFalse(composite.isSuccessful());
212 Assert.assertEquals(2, composite.getErrors().size());
213 Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
217 public void testExtractGroupActionsSupportBitmap() {
218 ActionType actionSupported = new ActionType(true,true, true, true, true, true, true, true, true, true, true,
219 true, true, true, true, true, true);
220 final List<Long> groupActionsSupportBitmap =
221 GroupUtil.extractGroupActionsSupportBitmap(Lists.newArrayList(actionSupported));
222 assertEquals(1, groupActionsSupportBitmap.size());
223 final Long bitmap = groupActionsSupportBitmap.get(0);
224 assertEquals(GROUP_ACTION_BITMAP, bitmap);
227 private RpcResult<Void> createBarrierFailureOutcome() {
228 return RpcResultBuilder.<Void>failed()
229 .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error")
233 private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
234 return RpcResultBuilder
235 .success(new AddGroupsBatchOutputBuilder()
236 .setBatchFailedGroupsOutput(Collections.<BatchFailedGroupsOutput>emptyList())
241 private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchFailureOutcome() {
242 final RpcResult<List<BatchFailedGroupsOutput>> batchOutcomeWithError = createBatchOutcomeWithError();
243 return RpcResultBuilder.<AddGroupsBatchOutput>failed()
244 .withResult(new AddGroupsBatchOutputBuilder()
245 .setBatchFailedGroupsOutput(batchOutcomeWithError.getResult())
247 .withRpcErrors(batchOutcomeWithError.getErrors())