Skip to content

Commit f625d6e

Browse files
author
Daman Arora
committed
Refactor affinity group mapping
1 parent 6e3ede9 commit f625d6e

File tree

4 files changed

+90
-68
lines changed

4 files changed

+90
-68
lines changed

‎api/src/main/java/com/cloud/kubernetes/cluster/KubernetesServiceHelper.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818

1919
import org.apache.cloudstack.acl.ControlledEntity;
2020

21+
import java.util.List;
2122
import java.util.Map;
2223

2324
import com.cloud.user.Account;
@@ -36,6 +37,6 @@ enum KubernetesClusterNodeType {
3637
boolean isValidNodeType(String nodeType);
3738
Map<String, Long> getServiceOfferingNodeTypeMap(Map<String, Map<String, String>> serviceOfferingNodeTypeMap);
3839
Map<String, Long> getTemplateNodeTypeMap(Map<String, Map<String, String>> templateNodeTypeMap);
39-
Map<String, String> getAffinityGroupNodeTypeMap(Map<String, Map<String, String>> affinityGroupNodeTypeMap);
40+
Map<String, List<Long>> getAffinityGroupNodeTypeMap(Map<String, Map<String, String>> affinityGroupNodeTypeMap);
4041
void cleanupForAccount(Account account);
4142
}

‎plugins/integrations/kubernetes-service/src/main/java/com/cloud/kubernetes/cluster/KubernetesServiceHelperImpl.java‎

Lines changed: 33 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,9 @@
1818

1919
import java.lang.reflect.Field;
2020
import java.lang.reflect.Modifier;
21+
import java.util.ArrayList;
2122
import java.util.HashMap;
23+
import java.util.List;
2224
import java.util.Map;
2325
import java.util.Objects;
2426

@@ -248,24 +250,24 @@ public Map<String, Long> getTemplateNodeTypeMap(Map<String, Map<String, String>>
248250
return mapping;
249251
}
250252

251-
protected void checkNodeTypeAffinityGroupEntryCompleteness(String nodeTypeStr, String affinityGroupUuids) {
252-
if (StringUtils.isAnyBlank(nodeTypeStr, affinityGroupUuids)) {
253+
protected void checkNodeTypeAffinityGroupEntryCompleteness(String nodeType, String affinityGroupUuids) {
254+
if (StringUtils.isAnyBlank(nodeType, affinityGroupUuids)) {
253255
String error = String.format("Any Node Type to Affinity Group entry should have a valid '%s' and '%s' values",
254256
VmDetailConstants.CKS_NODE_TYPE, VmDetailConstants.AFFINITY_GROUP);
255257
logger.error(error);
256258
throw new InvalidParameterValueException(error);
257259
}
258260
}
259261

260-
protected void checkNodeTypeAffinityGroupEntryNodeType(String nodeTypeStr) {
261-
if (!isValidNodeType(nodeTypeStr)) {
262-
String error = String.format("The provided value '%s' for Node Type is invalid", nodeTypeStr);
262+
protected void checkNodeTypeAffinityGroupEntryNodeType(String nodeType) {
263+
if (!isValidNodeType(nodeType)) {
264+
String error = String.format("The provided value '%s' for Node Type is invalid", nodeType);
263265
logger.error(error);
264266
throw new InvalidParameterValueException(error);
265267
}
266268
}
267269

268-
protected void validateAffinityGroupUuid(String affinityGroupUuid) {
270+
protected Long validateAffinityGroupUuidAndGetId(String affinityGroupUuid) {
269271
if (StringUtils.isBlank(affinityGroupUuid)) {
270272
String error = "Empty affinity group UUID provided";
271273
logger.error(error);
@@ -277,55 +279,52 @@ protected void validateAffinityGroupUuid(String affinityGroupUuid) {
277279
logger.error(error);
278280
throw new InvalidParameterValueException(error);
279281
}
282+
return affinityGroup.getId();
280283
}
281284

282-
protected String validateAndNormalizeAffinityGroupUuids(String affinityGroupUuids) {
285+
protected List<Long> validateAndGetAffinityGroupIds(String affinityGroupUuids) {
283286
String[] uuids = affinityGroupUuids.split(",");
284-
StringBuilder normalizedUuids = new StringBuilder();
285-
for (int i = 0; i < uuids.length; i++) {
286-
String uuid = uuids[i].trim();
287-
validateAffinityGroupUuid(uuid);
288-
if (i > 0) {
289-
normalizedUuids.append(",");
290-
}
291-
normalizedUuids.append(uuid);
287+
List<Long> affinityGroupIds = new ArrayList<>();
288+
for (String uuid : uuids) {
289+
String trimmedUuid = uuid.trim();
290+
Long affinityGroupId = validateAffinityGroupUuidAndGetId(trimmedUuid);
291+
affinityGroupIds.add(affinityGroupId);
292292
}
293-
return normalizedUuids.toString();
293+
return affinityGroupIds;
294294
}
295295

296-
protected void addNodeTypeAffinityGroupEntry(String nodeTypeStr, String validatedAffinityGroupUuids, Map<String, String> mapping) {
296+
protected void addNodeTypeAffinityGroupEntry(String nodeType, List<Long> affinityGroupIds, Map<String, List<Long>> nodeTypeToAffinityGroupIds) {
297297
if (logger.isDebugEnabled()) {
298-
logger.debug(String.format("Node Type: '%s' should use affinity group IDs: '%s'", nodeTypeStr, validatedAffinityGroupUuids));
298+
logger.debug(String.format("Node Type: '%s' should use affinity group IDs: '%s'", nodeType, affinityGroupIds));
299299
}
300-
KubernetesClusterNodeType nodeType = KubernetesClusterNodeType.valueOf(nodeTypeStr.toUpperCase());
301-
mapping.put(nodeType.name(), validatedAffinityGroupUuids);
300+
KubernetesClusterNodeType clusterNodeType = KubernetesClusterNodeType.valueOf(nodeType.toUpperCase());
301+
nodeTypeToAffinityGroupIds.put(clusterNodeType.name(), affinityGroupIds);
302302
}
303303

304-
protected void processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(Map<String, String> entry, Map<String, String> mapping) {
305-
if (MapUtils.isEmpty(entry)) {
304+
protected void processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(Map<String, String> nodeTypeAffinityConfig, Map<String, List<Long>> nodeTypeToAffinityGroupIds) {
305+
if (MapUtils.isEmpty(nodeTypeAffinityConfig)) {
306306
return;
307307
}
308-
String nodeTypeStr = entry.get(VmDetailConstants.CKS_NODE_TYPE);
309-
String affinityGroupUuids = entry.get(VmDetailConstants.AFFINITY_GROUP);
310-
checkNodeTypeAffinityGroupEntryCompleteness(nodeTypeStr, affinityGroupUuids);
311-
checkNodeTypeAffinityGroupEntryNodeType(nodeTypeStr);
308+
String nodeType = nodeTypeAffinityConfig.get(VmDetailConstants.CKS_NODE_TYPE);
309+
String affinityGroupUuids = nodeTypeAffinityConfig.get(VmDetailConstants.AFFINITY_GROUP);
310+
checkNodeTypeAffinityGroupEntryCompleteness(nodeType, affinityGroupUuids);
311+
checkNodeTypeAffinityGroupEntryNodeType(nodeType);
312312

313-
String validatedUuids = validateAndNormalizeAffinityGroupUuids(affinityGroupUuids);
314-
addNodeTypeAffinityGroupEntry(nodeTypeStr, validatedUuids, mapping);
313+
List<Long> affinityGroupIds = validateAndGetAffinityGroupIds(affinityGroupUuids);
314+
addNodeTypeAffinityGroupEntry(nodeType, affinityGroupIds, nodeTypeToAffinityGroupIds);
315315
}
316316

317317
@Override
318-
public Map<String, String> getAffinityGroupNodeTypeMap(Map<String, Map<String, String>> affinityGroupNodeTypeMap) {
319-
Map<String, String> mapping = new HashMap<>();
318+
public Map<String, List<Long>> getAffinityGroupNodeTypeMap(Map<String, Map<String, String>> affinityGroupNodeTypeMap) {
319+
Map<String, List<Long>> nodeTypeToAffinityGroupIds = new HashMap<>();
320320
if (MapUtils.isNotEmpty(affinityGroupNodeTypeMap)) {
321-
for (Map<String, String> entry : affinityGroupNodeTypeMap.values()) {
322-
processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(entry, mapping);
321+
for (Map<String, String> nodeTypeAffinityConfig : affinityGroupNodeTypeMap.values()) {
322+
processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(nodeTypeAffinityConfig, nodeTypeToAffinityGroupIds);
323323
}
324324
}
325-
return mapping;
325+
return nodeTypeToAffinityGroupIds;
326326
}
327327

328-
329328
public void cleanupForAccount(Account account) {
330329
kubernetesClusterService.cleanupForAccount(account);
331330
}

‎plugins/integrations/kubernetes-service/src/main/java/org/apache/cloudstack/api/command/user/kubernetes/cluster/CreateKubernetesClusterCmd.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
package org.apache.cloudstack.api.command.user.kubernetes.cluster;
1818

1919
import java.security.InvalidParameterException;
20+
import java.util.List;
2021
import java.util.Map;
2122
import java.util.Objects;
2223

@@ -327,7 +328,7 @@ public Map<String, Long> getTemplateNodeTypeMap() {
327328
return kubernetesServiceHelper.getTemplateNodeTypeMap(templateNodeTypeMap);
328329
}
329330

330-
public Map<String, String> getAffinityGroupNodeTypeMap() {
331+
public Map<String, List<Long>> getAffinityGroupNodeTypeMap() {
331332
return kubernetesServiceHelper.getAffinityGroupNodeTypeMap(affinityGroupNodeTypeMap);
332333
}
333334

‎plugins/integrations/kubernetes-service/src/test/java/com/cloud/kubernetes/cluster/KubernetesServiceHelperImplTest.java‎

Lines changed: 53 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,9 @@
1717
package com.cloud.kubernetes.cluster;
1818

1919

20+
import java.util.Arrays;
2021
import java.util.HashMap;
22+
import java.util.List;
2123
import java.util.Map;
2224
import java.util.UUID;
2325

@@ -218,115 +220,129 @@ public void testCheckNodeTypeAffinityGroupEntryNodeTypeValid() {
218220
}
219221

220222
@Test(expected = InvalidParameterValueException.class)
221-
public void testValidateAffinityGroupUuidBlank() {
222-
kubernetesServiceHelper.validateAffinityGroupUuid("");
223+
public void testValidateAffinityGroupUuidAndGetIdBlank() {
224+
kubernetesServiceHelper.validateAffinityGroupUuidAndGetId("");
223225
}
224226

225227
@Test(expected = InvalidParameterValueException.class)
226-
public void testValidateAffinityGroupUuidNotFound() {
228+
public void testValidateAffinityGroupUuidAndGetIdNotFound() {
227229
Mockito.when(affinityGroupDao.findByUuid("non-existent-uuid")).thenReturn(null);
228-
kubernetesServiceHelper.validateAffinityGroupUuid("non-existent-uuid");
230+
kubernetesServiceHelper.validateAffinityGroupUuidAndGetId("non-existent-uuid");
229231
}
230232

231233
@Test
232-
public void testValidateAffinityGroupUuidValid() {
234+
public void testValidateAffinityGroupUuidAndGetIdValid() {
233235
AffinityGroupVO affinityGroup = Mockito.mock(AffinityGroupVO.class);
236+
Mockito.when(affinityGroup.getId()).thenReturn(100L);
234237
Mockito.when(affinityGroupDao.findByUuid("valid-uuid")).thenReturn(affinityGroup);
235-
kubernetesServiceHelper.validateAffinityGroupUuid("valid-uuid");
238+
Long result = kubernetesServiceHelper.validateAffinityGroupUuidAndGetId("valid-uuid");
239+
Assert.assertEquals(Long.valueOf(100L), result);
236240
}
237241

238242
@Test
239-
public void testValidateAndNormalizeAffinityGroupUuidsSingleUuid() {
243+
public void testValidateAndGetAffinityGroupIdsSingleUuid() {
240244
AffinityGroupVO affinityGroup = Mockito.mock(AffinityGroupVO.class);
245+
Mockito.when(affinityGroup.getId()).thenReturn(1L);
241246
Mockito.when(affinityGroupDao.findByUuid("uuid1")).thenReturn(affinityGroup);
242247

243-
String result = kubernetesServiceHelper.validateAndNormalizeAffinityGroupUuids("uuid1");
244-
Assert.assertEquals("uuid1", result);
248+
List<Long> result = kubernetesServiceHelper.validateAndGetAffinityGroupIds("uuid1");
249+
Assert.assertEquals(1, result.size());
250+
Assert.assertEquals(Long.valueOf(1L), result.get(0));
245251
}
246252

247253
@Test
248-
public void testValidateAndNormalizeAffinityGroupUuidsMultipleUuids() {
254+
public void testValidateAndGetAffinityGroupIdsMultipleUuids() {
249255
AffinityGroupVO affinityGroup1 = Mockito.mock(AffinityGroupVO.class);
250256
AffinityGroupVO affinityGroup2 = Mockito.mock(AffinityGroupVO.class);
251257
AffinityGroupVO affinityGroup3 = Mockito.mock(AffinityGroupVO.class);
258+
Mockito.when(affinityGroup1.getId()).thenReturn(1L);
259+
Mockito.when(affinityGroup2.getId()).thenReturn(2L);
260+
Mockito.when(affinityGroup3.getId()).thenReturn(3L);
252261
Mockito.when(affinityGroupDao.findByUuid("uuid1")).thenReturn(affinityGroup1);
253262
Mockito.when(affinityGroupDao.findByUuid("uuid2")).thenReturn(affinityGroup2);
254263
Mockito.when(affinityGroupDao.findByUuid("uuid3")).thenReturn(affinityGroup3);
255264

256-
String result = kubernetesServiceHelper.validateAndNormalizeAffinityGroupUuids("uuid1,uuid2,uuid3");
257-
Assert.assertEquals("uuid1,uuid2,uuid3", result);
265+
List<Long> result = kubernetesServiceHelper.validateAndGetAffinityGroupIds("uuid1,uuid2,uuid3");
266+
Assert.assertEquals(3, result.size());
267+
Assert.assertEquals(Arrays.asList(1L, 2L, 3L), result);
258268
}
259269

260270
@Test
261-
public void testValidateAndNormalizeAffinityGroupUuidsWithSpaces() {
271+
public void testValidateAndGetAffinityGroupIdsWithSpaces() {
262272
AffinityGroupVO affinityGroup1 = Mockito.mock(AffinityGroupVO.class);
263273
AffinityGroupVO affinityGroup2 = Mockito.mock(AffinityGroupVO.class);
274+
Mockito.when(affinityGroup1.getId()).thenReturn(1L);
275+
Mockito.when(affinityGroup2.getId()).thenReturn(2L);
264276
Mockito.when(affinityGroupDao.findByUuid("uuid1")).thenReturn(affinityGroup1);
265277
Mockito.when(affinityGroupDao.findByUuid("uuid2")).thenReturn(affinityGroup2);
266278

267-
String result = kubernetesServiceHelper.validateAndNormalizeAffinityGroupUuids(" uuid1 , uuid2 ");
268-
Assert.assertEquals("uuid1,uuid2", result);
279+
List<Long> result = kubernetesServiceHelper.validateAndGetAffinityGroupIds(" uuid1 , uuid2 ");
280+
Assert.assertEquals(2, result.size());
281+
Assert.assertEquals(Arrays.asList(1L, 2L), result);
269282
}
270283

271284
@Test(expected = InvalidParameterValueException.class)
272-
public void testValidateAndNormalizeAffinityGroupUuidsOneInvalid() {
285+
public void testValidateAndGetAffinityGroupIdsOneInvalid() {
273286
AffinityGroupVO affinityGroup1 = Mockito.mock(AffinityGroupVO.class);
274287
Mockito.when(affinityGroupDao.findByUuid("uuid1")).thenReturn(affinityGroup1);
275288
Mockito.when(affinityGroupDao.findByUuid("invalid-uuid")).thenReturn(null);
276289

277-
kubernetesServiceHelper.validateAndNormalizeAffinityGroupUuids("uuid1,invalid-uuid");
290+
kubernetesServiceHelper.validateAndGetAffinityGroupIds("uuid1,invalid-uuid");
278291
}
279292

280293
@Test
281294
public void testAddNodeTypeAffinityGroupEntry() {
282-
Map<String, String> mapping = new HashMap<>();
283-
kubernetesServiceHelper.addNodeTypeAffinityGroupEntry("control", "uuid1,uuid2", mapping);
295+
Map<String, List<Long>> mapping = new HashMap<>();
296+
kubernetesServiceHelper.addNodeTypeAffinityGroupEntry("control", Arrays.asList(1L, 2L), mapping);
284297
Assert.assertEquals(1, mapping.size());
285-
Assert.assertEquals("uuid1,uuid2", mapping.get("CONTROL"));
298+
Assert.assertEquals(Arrays.asList(1L, 2L), mapping.get("CONTROL"));
286299
}
287300

288301
@Test
289302
public void testProcessNodeTypeAffinityGroupEntryAndAddToMappingIfValidEmptyEntry() {
290-
Map<String, String> mapping = new HashMap<>();
303+
Map<String, List<Long>> mapping = new HashMap<>();
291304
kubernetesServiceHelper.processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(new HashMap<>(), mapping);
292305
Assert.assertTrue(mapping.isEmpty());
293306
}
294307

295308
@Test
296309
public void testProcessNodeTypeAffinityGroupEntryAndAddToMappingIfValidValidEntry() {
297310
AffinityGroupVO affinityGroup = Mockito.mock(AffinityGroupVO.class);
311+
Mockito.when(affinityGroup.getId()).thenReturn(100L);
298312
Mockito.when(affinityGroupDao.findByUuid("affinity-group-uuid")).thenReturn(affinityGroup);
299313

300314
Map<String, String> entry = new HashMap<>();
301315
entry.put(VmDetailConstants.CKS_NODE_TYPE, "control");
302316
entry.put(VmDetailConstants.AFFINITY_GROUP, "affinity-group-uuid");
303317

304-
Map<String, String> mapping = new HashMap<>();
318+
Map<String, List<Long>> mapping = new HashMap<>();
305319
kubernetesServiceHelper.processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(entry, mapping);
306320
Assert.assertEquals(1, mapping.size());
307-
Assert.assertEquals("affinity-group-uuid", mapping.get("CONTROL"));
321+
Assert.assertEquals(Arrays.asList(100L), mapping.get("CONTROL"));
308322
}
309323

310324
@Test
311325
public void testProcessNodeTypeAffinityGroupEntryAndAddToMappingIfValidMultipleUuids() {
312326
AffinityGroupVO affinityGroup1 = Mockito.mock(AffinityGroupVO.class);
313327
AffinityGroupVO affinityGroup2 = Mockito.mock(AffinityGroupVO.class);
328+
Mockito.when(affinityGroup1.getId()).thenReturn(1L);
329+
Mockito.when(affinityGroup2.getId()).thenReturn(2L);
314330
Mockito.when(affinityGroupDao.findByUuid("uuid1")).thenReturn(affinityGroup1);
315331
Mockito.when(affinityGroupDao.findByUuid("uuid2")).thenReturn(affinityGroup2);
316332

317333
Map<String, String> entry = new HashMap<>();
318334
entry.put(VmDetailConstants.CKS_NODE_TYPE, "worker");
319335
entry.put(VmDetailConstants.AFFINITY_GROUP, "uuid1,uuid2");
320336

321-
Map<String, String> mapping = new HashMap<>();
337+
Map<String, List<Long>> mapping = new HashMap<>();
322338
kubernetesServiceHelper.processNodeTypeAffinityGroupEntryAndAddToMappingIfValid(entry, mapping);
323339
Assert.assertEquals(1, mapping.size());
324-
Assert.assertEquals("uuid1,uuid2", mapping.get("WORKER"));
340+
Assert.assertEquals(Arrays.asList(1L, 2L), mapping.get("WORKER"));
325341
}
326342

327343
@Test
328344
public void testGetAffinityGroupNodeTypeMapEmptyMap() {
329-
Map<String, String> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(null);
345+
Map<String, List<Long>> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(null);
330346
Assert.assertTrue(result.isEmpty());
331347

332348
result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(new HashMap<>());
@@ -336,9 +352,11 @@ public void testGetAffinityGroupNodeTypeMapEmptyMap() {
336352
@Test
337353
public void testGetAffinityGroupNodeTypeMapValidEntries() {
338354
AffinityGroupVO controlAffinityGroup = Mockito.mock(AffinityGroupVO.class);
355+
Mockito.when(controlAffinityGroup.getId()).thenReturn(100L);
339356
Mockito.when(affinityGroupDao.findByUuid("control-affinity-uuid")).thenReturn(controlAffinityGroup);
340357

341358
AffinityGroupVO workerAffinityGroup = Mockito.mock(AffinityGroupVO.class);
359+
Mockito.when(workerAffinityGroup.getId()).thenReturn(200L);
342360
Mockito.when(affinityGroupDao.findByUuid("worker-affinity-uuid")).thenReturn(workerAffinityGroup);
343361

344362
Map<String, Map<String, String>> affinityGroupNodeTypeMap = new HashMap<>();
@@ -353,17 +371,20 @@ public void testGetAffinityGroupNodeTypeMapValidEntries() {
353371
workerEntry.put(VmDetailConstants.AFFINITY_GROUP, "worker-affinity-uuid");
354372
affinityGroupNodeTypeMap.put("1", workerEntry);
355373

356-
Map<String, String> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(affinityGroupNodeTypeMap);
374+
Map<String, List<Long>> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(affinityGroupNodeTypeMap);
357375
Assert.assertEquals(2, result.size());
358-
Assert.assertEquals("control-affinity-uuid", result.get("CONTROL"));
359-
Assert.assertEquals("worker-affinity-uuid", result.get("WORKER"));
376+
Assert.assertEquals(Arrays.asList(100L), result.get("CONTROL"));
377+
Assert.assertEquals(Arrays.asList(200L), result.get("WORKER"));
360378
}
361379

362380
@Test
363-
public void testGetAffinityGroupNodeTypeMapMultipleUuidsPerNodeType() {
381+
public void testGetAffinityGroupNodeTypeMapMultipleIdsPerNodeType() {
364382
AffinityGroupVO ag1 = Mockito.mock(AffinityGroupVO.class);
365383
AffinityGroupVO ag2 = Mockito.mock(AffinityGroupVO.class);
366384
AffinityGroupVO ag3 = Mockito.mock(AffinityGroupVO.class);
385+
Mockito.when(ag1.getId()).thenReturn(1L);
386+
Mockito.when(ag2.getId()).thenReturn(2L);
387+
Mockito.when(ag3.getId()).thenReturn(3L);
367388
Mockito.when(affinityGroupDao.findByUuid("ag1")).thenReturn(ag1);
368389
Mockito.when(affinityGroupDao.findByUuid("ag2")).thenReturn(ag2);
369390
Mockito.when(affinityGroupDao.findByUuid("ag3")).thenReturn(ag3);
@@ -375,8 +396,8 @@ public void testGetAffinityGroupNodeTypeMapMultipleUuidsPerNodeType() {
375396
controlEntry.put(VmDetailConstants.AFFINITY_GROUP, "ag1,ag2,ag3");
376397
affinityGroupNodeTypeMap.put("0", controlEntry);
377398

378-
Map<String, String> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(affinityGroupNodeTypeMap);
399+
Map<String, List<Long>> result = kubernetesServiceHelper.getAffinityGroupNodeTypeMap(affinityGroupNodeTypeMap);
379400
Assert.assertEquals(1, result.size());
380-
Assert.assertEquals("ag1,ag2,ag3", result.get("CONTROL"));
401+
Assert.assertEquals(Arrays.asList(1L, 2L, 3L), result.get("CONTROL"));
381402
}
382403
}

0 commit comments

Comments
 (0)