9384121a978d67ad600f86428588060a73649062
[openflowplugin.git] / openflowplugin-impl / src / test / java / org / opendaylight / openflowplugin / impl / util / GroupUtilTest.java
1 /*
2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8
9 package org.opendaylight.openflowplugin.impl.util;
10
11 import static org.junit.Assert.assertEquals;
12
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;
40
41 /**
42  * Test for {@link GroupUtil}.
43  */
44 public class GroupUtilTest {
45
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;
51
52     @Test
53     public void testBuildGroupPath() {
54         final InstanceIdentifier<Node> nodePath = InstanceIdentifier
55                 .create(Nodes.class)
56                 .child(Node.class, new NodeKey(DUMMY_NODE_ID));
57
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());
62     }
63
64     @Test
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)));
69
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")
74                         .build()));
75
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());
81     }
82
83     protected Group createBatchGroup(final GroupId groupId) {
84         return new GroupBuilder().setGroupId(groupId).build();
85     }
86
87     @Test
88     public void testGroupAddTransformFailure() {
89         final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
90         checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
91     }
92
93     @Test
94     public void testGroupAddTransformFailureSuccess() {
95         final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
96         checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_ADD_TRANSFORM.apply(input));
97     }
98
99     @Test
100     public void testGroupRemoveTransformFailure() {
101         final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
102         checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
103     }
104
105     @Test
106     public void testFlowRemoveTransformSuccess() {
107         final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
108         checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_REMOVE_TRANSFORM.apply(input));
109     }
110
111     @Test
112     public void testFlowUpdateTransformFailure() {
113         final RpcResult<List<BatchFailedGroupsOutput>> input = createBatchOutcomeWithError();
114         checkBatchErrorOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
115     }
116
117     @Test
118     public void testFlowUpdateTransformSuccess() {
119         final RpcResult<List<BatchFailedGroupsOutput>> input = createEmptyBatchOutcome();
120         checkBatchSuccessOutcomeTransformation(GroupUtil.GROUP_UPDATE_TRANSFORM.apply(input));
121     }
122
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());
128     }
129
130     private RpcResult<List<BatchFailedGroupsOutput>> createEmptyBatchOutcome() {
131         return RpcResultBuilder
132                 .success(Collections.<BatchFailedGroupsOutput>emptyList())
133                 .build();
134     }
135
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)
141                         .build()))
142                 .build();
143     }
144
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());
150
151         Assert.assertEquals(1, output.getErrors().size());
152     }
153
154     @Test
155     public void testCreateComposingFunction_success_success() {
156         final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
157                 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
158
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);
164
165         Assert.assertTrue(composite.isSuccessful());
166         Assert.assertEquals(0, composite.getErrors().size());
167         Assert.assertEquals(0, composite.getResult().getBatchFailedGroupsOutput().size());
168     }
169
170     @Test
171     public void testCreateComposingFunction_failure_success() {
172         final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
173                 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
174
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);
180
181         Assert.assertFalse(composite.isSuccessful());
182         Assert.assertEquals(1, composite.getErrors().size());
183         Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
184     }
185
186     @Test
187     public void testCreateComposingFunction_success_failure() {
188         final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
189                 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
190
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);
196
197         Assert.assertFalse(composite.isSuccessful());
198         Assert.assertEquals(1, composite.getErrors().size());
199         Assert.assertEquals(0, composite.getResult().getBatchFailedGroupsOutput().size());
200     }
201
202     @Test
203     public void testCreateComposingFunction_failure_failure() {
204         final Function<Pair<RpcResult<AddGroupsBatchOutput>, RpcResult<SendBarrierOutput>>,
205                 RpcResult<AddGroupsBatchOutput>> compositeFunction = GroupUtil.createComposingFunction();
206
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);
212
213         Assert.assertFalse(composite.isSuccessful());
214         Assert.assertEquals(2, composite.getErrors().size());
215         Assert.assertEquals(1, composite.getResult().getBatchFailedGroupsOutput().size());
216     }
217
218     @Test
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());
226     }
227
228     private RpcResult<SendBarrierOutput> createBarrierFailureOutcome() {
229         return RpcResultBuilder.<SendBarrierOutput>failed()
230                 .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error")
231                 .build();
232     }
233
234     private RpcResult<AddGroupsBatchOutput> createAddGroupsBatchSuccessOutput() {
235         return RpcResultBuilder
236                 .success(new AddGroupsBatchOutputBuilder()
237                         .setBatchFailedGroupsOutput(Collections.emptyList())
238                         .build())
239                 .build();
240     }
241
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())
247                         .build())
248                 .withRpcErrors(batchOutcomeWithError.getErrors())
249                 .build();
250     }
251 }