src/test/java/org/onap/clamp/loop/LoopRepositoriesItCase.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP CLAMP
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights
   6  *                             reserved.
   7  * ================================================================================
   8  * Modifications Copyright (c) 2019 Samsung
   9  * ================================================================================
  10  *  Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END============================================
  22  * ===================================================================
  23  *
  24  */
  25
  26 package org.onap.clamp.loop;
  27
  28 import static org.assertj.core.api.Assertions.assertThat;
  29
  30 import com.google.gson.Gson;
  31 import com.google.gson.GsonBuilder;
  32 import com.google.gson.JsonObject;
  33 import java.time.Instant;
  34 import org.junit.Test;
  35 import org.junit.runner.RunWith;
  36 import org.onap.clamp.clds.Application;
  37 import org.onap.clamp.loop.log.LogType;
  38 import org.onap.clamp.loop.log.LoopLog;
  39 import org.onap.clamp.loop.log.LoopLogRepository;
  40 import org.onap.clamp.loop.service.Service;
  41 import org.onap.clamp.loop.service.ServicesRepository;
  42 import org.onap.clamp.loop.template.LoopElementModel;
  43 import org.onap.clamp.loop.template.LoopElementModelsRepository;
  44 import org.onap.clamp.loop.template.LoopTemplate;
  45 import org.onap.clamp.loop.template.LoopTemplatesRepository;
  46 import org.onap.clamp.loop.template.PolicyModel;
  47 import org.onap.clamp.loop.template.PolicyModelId;
  48 import org.onap.clamp.loop.template.PolicyModelsRepository;
  49 import org.onap.clamp.policy.microservice.MicroServicePolicy;
  50 import org.onap.clamp.policy.microservice.MicroServicePolicyService;
  51 import org.onap.clamp.policy.operational.OperationalPolicy;
  52 import org.onap.clamp.policy.operational.OperationalPolicyService;
  53 import org.springframework.beans.factory.annotation.Autowired;
  54 import org.springframework.boot.test.context.SpringBootTest;
  55 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  56 import org.springframework.transaction.annotation.Transactional;
  57
  58 @RunWith(SpringJUnit4ClassRunner.class)
  59 @SpringBootTest(classes = Application.class)
  60 public class LoopRepositoriesItCase {
  61
  62     private Gson gson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create();
  63
  64     @Autowired
  65     private LoopsRepository loopRepository;
  66
  67     @Autowired
  68     private MicroServicePolicyService microServicePolicyService;
  69
  70     @Autowired
  71     private OperationalPolicyService operationalPolicyService;
  72
  73     @Autowired
  74     private LoopLogRepository loopLogRepository;
  75
  76     @Autowired
  77     private LoopTemplatesRepository loopTemplateRepository;
  78
  79     @Autowired
  80     private LoopElementModelsRepository microServiceModelsRepository;
  81
  82     @Autowired
  83     private PolicyModelsRepository policyModelsRepository;
  84
  85     @Autowired
  86     private ServicesRepository servicesRepository;
  87
  88     private Service getService(String serviceDetails, String resourceDetails) {
  89         return new Service(serviceDetails, resourceDetails);
  90     }
  91
  92     private OperationalPolicy getOperationalPolicy(String configJson, String name, PolicyModel policyModel) {
  93         return new OperationalPolicy(name, null, new Gson().fromJson(configJson, JsonObject.class), policyModel,
  94                 null, null, null);
  95     }
  96
  97     private LoopElementModel getLoopElementModel(String yaml, String name, String policyType, String createdBy,
  98                                                  PolicyModel policyModel) {
  99         LoopElementModel model = new LoopElementModel(name, policyType, yaml);
 100         model.addPolicyModel(policyModel);
 101         return model;
 102     }
 103
 104     private PolicyModel getPolicyModel(String policyType, String policyModelTosca, String version,
 105                                        String policyAcronym) {
 106         return new PolicyModel(policyType, policyModelTosca, version, policyAcronym);
 107     }
 108
 109     private LoopTemplate getLoopTemplates(String name, String blueprint, String createdBy,
 110                                           Integer maxInstancesAllowed) {
 111         LoopTemplate template = new LoopTemplate(name, blueprint, maxInstancesAllowed, null);
 112         template.addLoopElementModel(getLoopElementModel("yaml", "microService1", "org.onap.policy.drools", createdBy,
 113                 getPolicyModel("org.onap.policy.drools", "yaml", "1.0.0", "Drools")));
 114         template.addLoopElementModel(getLoopElementModel("yaml", "oppolicy1", "org.onap.policy.drools.legacy",
 115                 createdBy, getPolicyModel("org.onap.policy.drools.legacy", "yaml", "1.0.0", "DroolsLegacy")));
 116         loopTemplateRepository.save(template);
 117         return template;
 118     }
 119
 120     private Loop getLoop(String name, String blueprint, String globalPropertiesJson,
 121                          String dcaeId, String dcaeUrl, String dcaeBlueprintId) {
 122         Loop loop = new Loop();
 123         loop.setName(name);
 124         loop.setGlobalPropertiesJson(new Gson().fromJson(globalPropertiesJson, JsonObject.class));
 125         loop.setLastComputedState(LoopState.DESIGN);
 126         loop.setDcaeDeploymentId(dcaeId);
 127         loop.setDcaeDeploymentStatusUrl(dcaeUrl);
 128         loop.setLoopTemplate(getLoopTemplates("templateName", "yaml", "toto", 1));
 129         return loop;
 130     }
 131
 132     private MicroServicePolicy getMicroServicePolicy(String name, String jsonRepresentation, String jsonProperties,
 133                                                      boolean shared, PolicyModel policyModel) {
 134         MicroServicePolicy microService = new MicroServicePolicy(name, policyModel, shared,
 135                 gson.fromJson(jsonRepresentation, JsonObject.class), null, null, null);
 136         microService.setConfigurationsJson(new Gson().fromJson(jsonProperties, JsonObject.class));
 137         return microService;
 138     }
 139
 140     private LoopLog getLoopLog(LogType type, String message, Loop loop) {
 141         return new LoopLog(message, type, "CLAMP", loop);
 142     }
 143
 144     /**
 145      * This method does a crud test and save a loop template and a loop object in db.
 146      */
 147     @Test
 148     @Transactional
 149     public void crudTest() {
 150         // Setup
 151         Loop loopTest = getLoop("ControlLoopTest", "yamlcontent", "{\"testname\":\"testvalue\"}",
 152                 "123456789", "https://dcaetest.org", "UUID-blueprint");
 153         OperationalPolicy opPolicy = this.getOperationalPolicy("{\"type\":\"GUARD\"}", "GuardOpPolicyTest",
 154                 getPolicyModel("org.onap.policy.drools.legacy", "yaml", "1.0.0", "DroolsLegacy"));
 155         loopTest.addOperationalPolicy(opPolicy);
 156         MicroServicePolicy microServicePolicy = getMicroServicePolicy("configPolicyTest", "{\"configtype\":\"json\"}",
 157                 "{\"param1\":\"value1\"}", true, getPolicyModel("org.onap.policy.drools", "yaml", "1.0.0", "Drools"));
 158         loopTest.addMicroServicePolicy(microServicePolicy);
 159         LoopLog loopLog = getLoopLog(LogType.INFO, "test message", loopTest);
 160         loopTest.addLog(loopLog);
 161         Service service = getService(
 162                 "{\"name\": \"vLoadBalancerMS\", \"UUID\": \"63cac700-ab9a-4115-a74f-7eac85e3fce0\"}", "{\"CP\": {}}");
 163         loopTest.setModelService(service);
 164
 165         // Attempt to save into the database the entire loop
 166         Loop loopInDb = loopRepository.save(loopTest);
 167         assertThat(loopInDb).isNotNull();
 168         assertThat(loopRepository.findById(loopInDb.getName()).get()).isNotNull();
 169         assertThat(loopInDb.getCreatedDate()).isNotNull();
 170         assertThat(loopInDb.getUpdatedDate()).isNotNull();
 171         assertThat(loopInDb.getUpdatedDate()).isEqualTo(loopInDb.getCreatedDate());
 172         assertThat(loopInDb.getName()).isEqualTo("ControlLoopTest");
 173         // Autogen id so now set the ID in the previous model so that we can compare the
 174         // objects
 175         loopLog.setId(((LoopLog) loopInDb.getLoopLogs().toArray()[0]).getId());
 176
 177         assertThat(loopInDb).isEqualToIgnoringGivenFields(loopTest, "components", "createdDate", "updatedDate",
 178                 "createdBy", "updatedBy");
 179         assertThat(loopRepository.existsById(loopTest.getName())).isEqualTo(true);
 180         assertThat(operationalPolicyService.isExisting(opPolicy.getName())).isEqualTo(true);
 181         assertThat(microServicePolicyService.isExisting(microServicePolicy.getName())).isEqualTo(true);
 182         assertThat(loopLogRepository.existsById(loopLog.getId())).isEqualTo(true);
 183         assertThat(loopTemplateRepository.existsById(loopInDb.getLoopTemplate().getName())).isEqualTo(true);
 184         assertThat(loopTemplateRepository.existsById(loopInDb.getLoopTemplate().getName())).isEqualTo(true);
 185         assertThat(servicesRepository.existsById(loopInDb.getModelService().getServiceUuid())).isEqualTo(true);
 186         assertThat(microServiceModelsRepository.existsById(
 187                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getName()))
 188                 .isEqualTo(true);
 189         assertThat(policyModelsRepository.existsById(new PolicyModelId(
 190                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getPolicyModels()
 191                         .first().getPolicyModelType(),
 192                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getPolicyModels()
 193                         .first().getVersion()))).isEqualTo(true);
 194
 195         // Now attempt to read from database
 196         Loop loopInDbRetrieved = loopRepository.findById(loopTest.getName()).get();
 197         assertThat(loopInDbRetrieved).isEqualToIgnoringGivenFields(loopTest, "components", "createdDate", "updatedDate",
 198                 "createdBy", "updatedBy");
 199         assertThat(loopInDbRetrieved).isEqualToComparingOnlyGivenFields(loopInDb, "createdDate", "updatedDate",
 200                 "createdBy", "updatedBy");
 201         assertThat((LoopLog) loopInDbRetrieved.getLoopLogs().toArray()[0]).isEqualToComparingFieldByField(loopLog);
 202         assertThat((OperationalPolicy) loopInDbRetrieved.getOperationalPolicies().toArray()[0])
 203                 .isEqualToIgnoringGivenFields(opPolicy, "createdDate", "updatedDate", "createdBy", "updatedBy");
 204         assertThat(((OperationalPolicy) loopInDbRetrieved.getOperationalPolicies().toArray()[0]).getCreatedDate())
 205                 .isNotNull();
 206         assertThat(((OperationalPolicy) loopInDbRetrieved.getOperationalPolicies().toArray()[0]).getUpdatedDate())
 207                 .isNotNull();
 208         assertThat(((OperationalPolicy) loopInDbRetrieved.getOperationalPolicies().toArray()[0]).getCreatedBy())
 209                 .isNotNull();
 210         assertThat(((OperationalPolicy) loopInDbRetrieved.getOperationalPolicies().toArray()[0]).getUpdatedBy())
 211                 .isNotNull();
 212
 213         assertThat((MicroServicePolicy) loopInDbRetrieved.getMicroServicePolicies().toArray()[0])
 214                 .isEqualToIgnoringGivenFields(microServicePolicy, "createdDate", "updatedDate", "createdBy",
 215                         "updatedBy");
 216
 217         // Attempt an update
 218         ((LoopLog) loopInDbRetrieved.getLoopLogs().toArray()[0]).setLogInstant(Instant.now());
 219         loopInDbRetrieved.setLastComputedState(LoopState.RUNNING);
 220         Loop loopInDbRetrievedUpdated = loopRepository.saveAndFlush(loopInDbRetrieved);
 221         // Loop loopInDbRetrievedUpdated =
 222         // loopRepository.findById(loopTest.getName()).get();
 223         assertThat((LoopLog) loopInDbRetrievedUpdated.getLoopLogs().toArray()[0])
 224                 .isEqualToComparingFieldByField(loopInDbRetrieved.getLoopLogs().toArray()[0]);
 225         // UpdatedDate should have been changed
 226         assertThat(loopInDbRetrievedUpdated.getUpdatedDate()).isNotEqualTo(loopInDbRetrievedUpdated.getCreatedDate());
 227         // createdDate should have NOT been changed
 228         assertThat(loopInDbRetrievedUpdated.getCreatedDate()).isEqualTo(loopInDb.getCreatedDate());
 229         // other audit are the same
 230         assertThat(loopInDbRetrievedUpdated.getCreatedBy()).isEqualTo("Not found");
 231         assertThat(loopInDbRetrievedUpdated.getUpdatedBy()).isEqualTo("Not found");
 232
 233         // Attempt to delete the object and check it has well been cascaded
 234
 235         loopRepository.delete(loopInDbRetrieved);
 236         assertThat(loopRepository.existsById(loopTest.getName())).isEqualTo(false);
 237         assertThat(operationalPolicyService.isExisting(opPolicy.getName())).isEqualTo(false);
 238         assertThat(microServicePolicyService.isExisting(microServicePolicy.getName())).isEqualTo(true);
 239         assertThat(loopLogRepository.existsById(loopLog.getId())).isEqualTo(false);
 240         assertThat(loopTemplateRepository.existsById(loopInDb.getLoopTemplate().getName())).isEqualTo(true);
 241         assertThat(servicesRepository.existsById(loopInDb.getModelService().getServiceUuid())).isEqualTo(true);
 242         assertThat(microServiceModelsRepository.existsById(
 243                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getName()))
 244                 .isEqualTo(true);
 245
 246         assertThat(policyModelsRepository.existsById(new PolicyModelId(
 247                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getPolicyModels()
 248                         .first().getPolicyModelType(),
 249                 loopInDb.getLoopTemplate().getLoopElementModelsUsed().first().getLoopElementModel().getPolicyModels()
 250                         .first().getVersion()))).isEqualTo(true);
 251
 252     }
 253 }