main/src/test/java/org/onap/policy/pap/main/rest/TestPdpGroupCreateOrUpdateProvider.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP PAP
   4  * ================================================================================
   5  * Copyright (C) 2019 Nordix Foundation.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.main.rest;
  22
  23 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertSame;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.mockito.Matchers.any;
  29 import static org.mockito.Mockito.never;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.ArrayList;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.List;
  37 import java.util.TreeMap;
  38 import javax.ws.rs.core.Response.Status;
  39 import org.junit.AfterClass;
  40 import org.junit.Before;
  41 import org.junit.Test;
  42 import org.onap.policy.common.utils.services.Registry;
  43 import org.onap.policy.models.base.PfModelException;
  44 import org.onap.policy.models.pdp.concepts.PdpGroup;
  45 import org.onap.policy.models.pdp.concepts.PdpGroups;
  46 import org.onap.policy.models.pdp.concepts.PdpStateChange;
  47 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  48 import org.onap.policy.models.pdp.concepts.PdpUpdate;
  49 import org.onap.policy.models.pdp.enums.PdpState;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  51
  52 public class TestPdpGroupCreateOrUpdateProvider extends ProviderSuper {
  53     private static final String EXPECTED_EXCEPTION = "expected exception";
  54
  55     private static final String PDP2 = "pdpB";
  56     private static final String PDP4 = "pdpD";
  57
  58     private PdpGroupCreateOrUpdateProvider prov;
  59
  60     @AfterClass
  61     public static void tearDownAfterClass() {
  62         Registry.newRegistry();
  63     }
  64
  65     /**
  66      * Configures mocks and objects.
  67      *
  68      * @throws Exception if an error occurs
  69      */
  70     @Override
  71     @Before
  72     public void setUp() throws Exception {
  73
  74         super.setUp();
  75
  76         when(dao.getPolicyTypeList("typeA", "100.2.3")).thenReturn(Arrays.asList(loadPolicyType("daoPolicyType.json")));
  77
  78         prov = new PdpGroupCreateOrUpdateProvider();
  79     }
  80
  81     @Test
  82     public void testCreateOrUpdateGroups() throws Exception {
  83         prov.createOrUpdateGroups(loadPdpGroups("emptyGroups.json"));
  84
  85         // no groups, so no action should have been taken
  86         assertNoGroupAction();
  87     }
  88
  89     @Test
  90     public void testCreateOrUpdateGroups_InvalidRequest() throws Exception {
  91         assertThatThrownBy(() -> prov.createOrUpdateGroups(new PdpGroups())).isInstanceOf(PfModelException.class)
  92             .hasMessageContaining("is null");
  93
  94         assertNoGroupAction();
  95     }
  96
  97     @Test
  98     public void testCreateOrUpdate_Invalid() throws Exception {
  99         PdpGroups groups = loadPdpGroups("createGroups.json");
 100         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 101
 102         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 103             .hasMessageContaining("pdpGroupState");
 104
 105         assertNoGroupAction();
 106     }
 107
 108     @Test
 109     public void testAddGroup() throws Exception {
 110         PdpGroups groups = loadPdpGroups("createGroups.json");
 111         PdpGroup group = groups.getGroups().get(0);
 112         group.setPdpGroupState(PdpState.PASSIVE);
 113
 114         prov.createOrUpdateGroups(groups);
 115
 116         // should not have updated the state
 117         assertEquals(PdpState.PASSIVE, group.getPdpGroupState());
 118
 119         assertSame(group, getGroupCreates().get(0));
 120     }
 121
 122     @Test
 123     public void testAddGroup_Invalid() throws Exception {
 124         PdpGroups groups = loadPdpGroups("createGroups.json");
 125         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 126
 127         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 128             .hasMessageContaining("pdpGroupState");
 129
 130         assertNoGroupAction();
 131     }
 132
 133     @Test
 134     public void testAddGroup_InvalidSubGroup() throws Exception {
 135         PdpGroups groups = loadPdpGroups("createGroups.json");
 136
 137         groups.getGroups().get(0).getPdpSubgroups().get(0).getSupportedPolicyTypes().get(0).setVersion("99.99.99");
 138
 139         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 140             .hasMessageContaining("unknown policy type");
 141
 142         assertNoGroupAction();
 143     }
 144
 145     @Test
 146     public void testValidateGroupOnly_NullState() throws PfModelException {
 147         PdpGroups groups = loadPdpGroups("createGroups.json");
 148         groups.getGroups().get(0).setPdpGroupState(null);
 149         prov.createOrUpdateGroups(groups);
 150     }
 151
 152     @Test
 153     public void testValidateGroupOnly_Active() throws PfModelException {
 154         PdpGroups groups = loadPdpGroups("createGroups.json");
 155         groups.getGroups().get(0).setPdpGroupState(PdpState.ACTIVE);
 156         prov.createOrUpdateGroups(groups);
 157     }
 158
 159     @Test
 160     public void testValidateGroupOnly_Passive() throws PfModelException {
 161         PdpGroups groups = loadPdpGroups("createGroups.json");
 162         groups.getGroups().get(0).setPdpGroupState(PdpState.PASSIVE);
 163         prov.createOrUpdateGroups(groups);
 164     }
 165
 166     @Test
 167     public void testValidateGroupOnly_Invalid() {
 168         PdpGroups groups = loadPdpGroups("createGroups.json");
 169         groups.getGroups().get(0).setPdpGroupState(PdpState.TERMINATED);
 170
 171         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 172             .hasMessageContaining("pdpGroupState");
 173     }
 174
 175     @Test
 176     public void testUpdateGroup() throws Exception {
 177         PdpGroups groups = loadPdpGroups("createGroups.json");
 178
 179         // DB group = new group
 180         PdpGroup group = new PdpGroup(groups.getGroups().get(0));
 181         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 182
 183         prov.createOrUpdateGroups(groups);
 184
 185         assertNoGroupAction();
 186     }
 187
 188     @Test
 189     public void testUpdateGroup_PropertiesChanged() throws Exception {
 190         PdpGroups groups = loadPdpGroups("createGroups.json");
 191
 192         PdpGroup group = new PdpGroup(groups.getGroups().get(0));
 193         group.setProperties(new TreeMap<>());
 194
 195         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 196
 197         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 198             .hasMessageContaining("properties");
 199
 200         assertNoGroupAction();
 201     }
 202
 203     @Test
 204     public void testUpdateGroup_NewDescription() throws Exception {
 205         PdpGroups groups = loadPdpGroups("createGroups.json");
 206         PdpGroup newgrp = groups.getGroups().get(0);
 207         PdpGroup group = new PdpGroup(newgrp);
 208         group.setDescription("old description");
 209         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 210
 211         prov.createOrUpdateGroups(groups);
 212
 213         assertGroupUpdateOnly(group);
 214
 215         assertEquals(group.getDescription(), "my description");
 216         assertEquals(newgrp.toString(), group.toString());
 217     }
 218
 219     @Test
 220     public void testUpdateGroup_NewState() throws Exception {
 221         PdpGroups groups = loadPdpGroups("createGroups.json");
 222         PdpGroup newgrp = groups.getGroups().get(0);
 223         PdpGroup group = new PdpGroup(newgrp);
 224         group.setPdpGroupState(PdpState.TEST);
 225         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 226
 227         prov.createOrUpdateGroups(groups);
 228
 229         assertGroupUpdateOnly(group);
 230
 231         assertEquals(PdpState.ACTIVE, group.getPdpGroupState());
 232         assertEquals(newgrp.toString(), group.toString());
 233     }
 234
 235     @Test
 236     public void testUpdateGroup_NewSubGroup() throws Exception {
 237         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 238         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 239         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 240
 241         prov.createOrUpdateGroups(groups);
 242
 243         PdpGroup newgrp = groups.getGroups().get(0);
 244         assertEquals(newgrp.toString(), group.toString());
 245         assertGroupUpdateOnly(group);
 246     }
 247
 248     @Test
 249     public void testUpdateGroup_UpdatedSubGroup() throws Exception {
 250         PdpGroups groups = loadPdpGroups("createGroups.json");
 251         PdpGroup newgrp = groups.getGroups().get(0);
 252         PdpGroup group = new PdpGroup(newgrp);
 253         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 254
 255         // something different in this subgroup
 256         group.getPdpSubgroups().get(0).setDesiredInstanceCount(10);
 257
 258         prov.createOrUpdateGroups(groups);
 259
 260         assertEquals(newgrp.toString(), group.toString());
 261         assertGroupUpdateOnly(group);
 262     }
 263
 264     @Test
 265     public void testUpdateGroup_notifyPdpsDelSubGroups() throws Exception {
 266         PdpGroup dbgroup = new PdpGroup(loadPdpGroups("createGroupsDelSub.json").getGroups().get(0));
 267         when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
 268
 269         PdpGroups groups = loadPdpGroups("createGroups.json");
 270
 271         prov.createOrUpdateGroups(groups);
 272
 273         // verify that DB group was updated
 274         List<PdpGroup> updates = getGroupUpdates();
 275         assertEquals(1, updates.size());
 276         dbgroup = updates.get(0);
 277
 278         PdpGroup newgrp = groups.getGroups().get(0);
 279
 280         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 281         Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
 282
 283         assertEquals(newgrp.toString(), dbgroup.toString());
 284
 285         // no deployment notifications
 286         verify(notifier, never()).addDeploymentData(any());
 287
 288         // this requires a PDP UPDATE message
 289         List<PdpUpdate> pdpUpdates = getUpdateRequests(2);
 290         assertEquals(2, pdpUpdates.size());
 291
 292         PdpUpdate pdpUpdate = pdpUpdates.get(0);
 293         assertEquals(PDP2, pdpUpdate.getName());
 294         assertNull(pdpUpdate.getPdpGroup());
 295
 296         pdpUpdate = pdpUpdates.get(1);
 297         assertEquals(PDP4, pdpUpdate.getName());
 298         assertNull(pdpUpdate.getPdpGroup());
 299
 300         // it also requires a PDP STATE-CHANGE message
 301         List<PdpStateChange> changes = getStateChangeRequests(2);
 302         assertEquals(2, changes.size());
 303
 304         PdpStateChange change = changes.get(0);
 305         assertEquals(PDP2, change.getName());
 306         assertEquals(PdpState.PASSIVE, change.getState());
 307
 308         change = changes.get(1);
 309         assertEquals(PDP4, change.getName());
 310         assertEquals(PdpState.PASSIVE, change.getState());
 311     }
 312
 313     @Test
 314     public void testUpdateField_Unchanged() throws Exception {
 315         PdpGroups groups = loadPdpGroups("createGroups.json");
 316         PdpGroup newgrp = groups.getGroups().get(0);
 317         PdpGroup group = new PdpGroup(newgrp);
 318         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 319
 320         prov.createOrUpdateGroups(groups);
 321
 322         assertNoGroupAction();
 323     }
 324
 325     @Test
 326     public void testUpdateField_WasNull() throws Exception {
 327         PdpGroups groups = loadPdpGroups("createGroups.json");
 328         PdpGroup newgrp = groups.getGroups().get(0);
 329         PdpGroup group = new PdpGroup(newgrp);
 330         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 331
 332         group.setDescription(null);
 333
 334         prov.createOrUpdateGroups(groups);
 335
 336         assertEquals(newgrp.toString(), group.toString());
 337         assertGroupUpdateOnly(group);
 338     }
 339
 340     @Test
 341     public void testUpdateField_NowNull() throws Exception {
 342         PdpGroups groups = loadPdpGroups("createGroups.json");
 343         PdpGroup newgrp = groups.getGroups().get(0);
 344         PdpGroup group = new PdpGroup(newgrp);
 345         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 346
 347         newgrp.setDescription(null);
 348
 349         prov.createOrUpdateGroups(groups);
 350
 351         assertEquals(newgrp.toString(), group.toString());
 352         assertGroupUpdateOnly(group);
 353     }
 354
 355     @Test
 356     public void testUpdateField_Changed() throws Exception {
 357         PdpGroups groups = loadPdpGroups("createGroups.json");
 358         PdpGroup newgrp = groups.getGroups().get(0);
 359         PdpGroup group = new PdpGroup(newgrp);
 360         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 361
 362         newgrp.setDescription(group.getDescription() + "-changed");
 363
 364         prov.createOrUpdateGroups(groups);
 365
 366         assertEquals(newgrp.toString(), group.toString());
 367         assertGroupUpdateOnly(group);
 368     }
 369
 370     @Test
 371     public void testAddSubGroup() throws Exception {
 372         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 373         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 374         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 375
 376         prov.createOrUpdateGroups(groups);
 377
 378         PdpGroup newgrp = groups.getGroups().get(0);
 379
 380         PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
 381         newsub.setCurrentInstanceCount(0);
 382         newsub.setPdpInstances(new ArrayList<>(0));
 383
 384         assertEquals(newgrp.toString(), group.toString());
 385         assertGroupUpdateOnly(group);
 386     }
 387
 388     /**
 389      * Tests addSubgroup() when the new subgroup has a wild-card policy type.
 390      *
 391      * @throws Exception if an error occurs
 392      */
 393     @Test
 394     public void testAddSubGroupWildCardPolicyType() throws Exception {
 395         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("daoPolicyListWildCard.json"));
 396         when(dao.getPolicyTypeList("some.*", "2.3.4")).thenReturn(Collections.emptyList());
 397
 398         PdpGroups groups = loadPdpGroups("createGroupsWildCard.json");
 399         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 400         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 401
 402         prov.createOrUpdateGroups(groups);
 403
 404         PdpGroup newgrp = groups.getGroups().get(0);
 405
 406         PdpSubGroup newsub = newgrp.getPdpSubgroups().get(1);
 407         newsub.setCurrentInstanceCount(0);
 408         newsub.setPdpInstances(new ArrayList<>(0));
 409
 410         assertEquals(newgrp.toString(), group.toString());
 411     }
 412
 413     @Test
 414     public void testAddSubGroup_ValidationPolicyTypeNotFound() throws Exception {
 415         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 416         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 417         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 418
 419         when(dao.getPolicyTypeList(any(), any())).thenReturn(Collections.emptyList());
 420
 421         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).hasMessageContaining("unknown policy type");
 422     }
 423
 424     @Test
 425     public void testAddSubGroup_ValidationPolicyTypeDaoEx() throws Exception {
 426         PdpGroups groups = loadPdpGroups("createGroupsNewSub.json");
 427         PdpGroup group = loadPdpGroups("createGroups.json").getGroups().get(0);
 428         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 429
 430         PfModelException exc = new PfModelException(Status.CONFLICT, EXPECTED_EXCEPTION);
 431         when(dao.getPolicyTypeList(any(), any())).thenThrow(exc);
 432
 433         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isSameAs(exc);
 434     }
 435
 436     @Test
 437     public void testAddSubGroup_ValidateVersionPrefixMatch() throws Exception {
 438         PdpGroups groups = loadPdpGroups("createGroups.json");
 439         PdpGroup newgrp = groups.getGroups().get(0);
 440         PdpGroup dbgroup = new PdpGroup(newgrp);
 441         when(dao.getPdpGroups(dbgroup.getName())).thenReturn(Arrays.asList(dbgroup));
 442
 443         when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("createGroupNewPolicy.json"))
 444             .thenReturn(loadPolicies("daoPolicyList.json")).thenReturn(loadPolicies("createGroupNewPolicy.json"));
 445
 446         PdpGroups reqgroups = loadPdpGroups("createGroupsVersPrefix.json");
 447
 448         prov.createOrUpdateGroups(reqgroups);
 449
 450         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 451         Collections.sort(dbgroup.getPdpSubgroups().get(0).getPolicies());
 452
 453         assertEquals(newgrp.toString(), dbgroup.toString());
 454     }
 455
 456     @Test
 457     public void testUpdateSubGroup_Invalid() throws Exception {
 458         PdpGroups groups = loadPdpGroups("createGroups.json");
 459         PdpGroup newgrp = groups.getGroups().get(0);
 460         PdpGroup group = new PdpGroup(newgrp);
 461         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 462
 463         // change properties
 464         newgrp.getPdpSubgroups().get(0).setProperties(new TreeMap<>());
 465
 466         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 467             .hasMessageContaining("properties");
 468
 469         assertNoGroupAction();
 470     }
 471
 472     @Test
 473     public void testUpdateSubGroup_SupportedPolicies() throws Exception {
 474         PdpGroups groups = loadPdpGroups("createGroups.json");
 475         PdpGroup newgrp = groups.getGroups().get(0);
 476         PdpGroup group = new PdpGroup(newgrp);
 477         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 478
 479         newgrp.getPdpSubgroups().get(0).getSupportedPolicyTypes()
 480             .add(new ToscaPolicyTypeIdentifier("typeX.*", "9.8.7"));
 481
 482         prov.createOrUpdateGroups(groups);
 483
 484         assertEquals(newgrp.toString(), group.toString());
 485         assertGroupUpdateOnly(group);
 486     }
 487
 488     @Test
 489     public void testUpdateSubGroup_DesiredCount() throws Exception {
 490         PdpGroups groups = loadPdpGroups("createGroups.json");
 491         PdpGroup newgrp = groups.getGroups().get(0);
 492         PdpGroup group = new PdpGroup(newgrp);
 493         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 494
 495         newgrp.getPdpSubgroups().get(0).setDesiredInstanceCount(20);
 496
 497         prov.createOrUpdateGroups(groups);
 498
 499         assertEquals(newgrp.toString(), group.toString());
 500         assertGroupUpdateOnly(group);
 501     }
 502
 503     @Test
 504     public void testUpdateSubGroup_Unchanged() throws Exception {
 505         PdpGroups groups = loadPdpGroups("createGroups.json");
 506         PdpGroup newgrp = groups.getGroups().get(0);
 507         PdpGroup group = new PdpGroup(newgrp);
 508         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 509
 510         prov.createOrUpdateGroups(groups);
 511
 512         Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
 513         Collections.sort(group.getPdpSubgroups().get(0).getPolicies());
 514
 515         assertEquals(newgrp.toString(), group.toString());
 516
 517         // no notifications
 518         verify(notifier, never()).addDeploymentData(any());
 519         verify(notifier, never()).addUndeploymentData(any());
 520
 521         // no group updates
 522         assertNoGroupAction();
 523     }
 524
 525     @Test
 526     public void testValidateSubGroup_PropertiesMismatch() throws Exception {
 527         PdpGroups groups = loadPdpGroups("createGroups.json");
 528         PdpGroup newgrp = groups.getGroups().get(0);
 529         PdpGroup group = new PdpGroup(newgrp);
 530         when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
 531
 532         newgrp.setProperties(new TreeMap<>());
 533
 534         assertThatThrownBy(() -> prov.createOrUpdateGroups(groups)).isInstanceOf(PfModelException.class)
 535             .hasMessageContaining("properties");
 536
 537         assertNoGroupAction();
 538     }
 539
 540     protected void assertUpdate(List<PdpUpdate> updates, String groupName, String pdpType, String pdpName) {
 541
 542         PdpUpdate update = updates.remove(0);
 543
 544         assertEquals(groupName, update.getPdpGroup());
 545         assertEquals(pdpType, update.getPdpSubgroup());
 546         assertEquals(pdpName, update.getName());
 547         assertTrue(update.getPolicies().contains(policy1));
 548     }
 549
 550     private void assertNoGroupAction() throws Exception {
 551         verify(dao, never()).createPdpGroups(any());
 552         verify(dao, never()).updatePdpGroups(any());
 553         verify(reqmap, never()).addRequest(any(), any());
 554     }
 555
 556     private void assertGroupUpdateOnly(PdpGroup group) throws Exception {
 557         verify(dao, never()).createPdpGroups(any());
 558         verify(reqmap, never()).addRequest(any(), any());
 559
 560         List<PdpGroup> updates = getGroupUpdates();
 561         assertEquals(Arrays.asList(group), updates);
 562     }
 563 }