auth/cli-codegen/src/test/java/org/onap/policy/apex/auth/clicodegen/CodeGeneratorCliEditorTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  *  Modifications Copyright (C) 2019 Samsung Electronics Co., Ltd.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.apex.auth.clicodegen;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.fail;
  26
  27 import java.io.File;
  28 import java.io.FileInputStream;
  29 import java.io.FileNotFoundException;
  30 import java.io.FileWriter;
  31 import java.io.IOException;
  32 import java.util.ArrayList;
  33 import java.util.Collection;
  34 import java.util.Collections;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Map.Entry;
  38 import org.junit.Test;
  39 import org.onap.policy.apex.model.basicmodel.concepts.AxArtifactKey;
  40 import org.onap.policy.apex.model.basicmodel.concepts.AxReferenceKey;
  41 import org.onap.policy.apex.model.basicmodel.handling.ApexModelException;
  42 import org.onap.policy.apex.model.basicmodel.handling.ApexModelReader;
  43 import org.onap.policy.apex.model.contextmodel.concepts.AxContextAlbum;
  44 import org.onap.policy.apex.model.contextmodel.concepts.AxContextSchema;
  45 import org.onap.policy.apex.model.eventmodel.concepts.AxEvent;
  46 import org.onap.policy.apex.model.eventmodel.concepts.AxField;
  47 import org.onap.policy.apex.model.policymodel.concepts.AxPolicy;
  48 import org.onap.policy.apex.model.policymodel.concepts.AxPolicyModel;
  49 import org.onap.policy.apex.model.policymodel.concepts.AxState;
  50 import org.onap.policy.apex.model.policymodel.concepts.AxStateFinalizerLogic;
  51 import org.onap.policy.apex.model.policymodel.concepts.AxStateOutput;
  52 import org.onap.policy.apex.model.policymodel.concepts.AxStateTaskReference;
  53 import org.onap.policy.apex.model.policymodel.concepts.AxTask;
  54 import org.onap.policy.apex.model.policymodel.concepts.AxTaskLogic;
  55 import org.onap.policy.apex.model.policymodel.concepts.AxTaskParameter;
  56 import org.onap.policy.apex.model.policymodel.concepts.AxTaskSelectionLogic;
  57 import org.stringtemplate.v4.ST;
  58
  59 /**
  60  * Test CLI code generation.
  61  */
  62 public class CodeGeneratorCliEditorTest {
  63
  64     private SupportKeyInfoGetter kig;
  65     private File outFile = null;
  66
  67     @Test
  68     public void test() throws IOException {
  69         final CodeGeneratorCliEditor codeGen = new CodeGeneratorCliEditor();
  70
  71         outFile = File.createTempFile("ApexTestGenerated", ".apex");
  72
  73         ApexModelReader<AxPolicyModel> modelReader = null;
  74         try {
  75             modelReader = new ApexModelReader<>(AxPolicyModel.class);
  76         } catch (ApexModelException e1) {
  77             fail("test should not throw an exception");
  78         }
  79         modelReader.setValidateFlag(false);
  80         AxPolicyModel apexPolicyModel = null;
  81         try {
  82             apexPolicyModel = modelReader
  83                             .read(new FileInputStream(new File("src/test/resources/models/TestPolicyModel.json")));
  84         } catch (ApexModelException | FileNotFoundException e) {
  85             fail("test should not throw an exception");
  86         }
  87
  88         assertEquals(0, generateCli(codeGen, apexPolicyModel));
  89     }
  90
  91     /**
  92      * Generate the CLI from the model.
  93      *
  94      * @param codeGen the code generator
  95      * @param policyModel the policy model
  96      * @throws IOException  on generation exceptions
  97      */
  98     private int generateCli(final CodeGeneratorCliEditor codeGen, final AxPolicyModel policyModel) throws IOException {
  99         kig = new SupportKeyInfoGetter(policyModel);
 100
 101         // Order is important. 0: model, 1: context schemas, 2: tasks, 3: events, 4: ContextAlbums, 5: Policies
 102         // 0: model
 103         final AxArtifactKey pmkey = policyModel.getKey();
 104         codeGen.addModelParams(kig.getName(pmkey), kig.getVersion(pmkey), kig.getUuid(pmkey), kig.getDesc(pmkey));
 105
 106         // 1: Context Schemas
 107         for (final AxContextSchema s : policyModel.getSchemas().getSchemasMap().values()) {
 108             final AxArtifactKey key = s.getKey();
 109
 110             codeGen.addSchemaDeclaration(kig.getName(key), kig.getVersion(key), kig.getUuid(key), kig.getDesc(key),
 111                             s.getSchemaFlavour(), s.getSchema());
 112         }
 113
 114         // 2: tasks
 115         for (final AxTask t : policyModel.getTasks().getTaskMap().values()) {
 116             final AxArtifactKey key = t.getKey();
 117             final List<ST> infields = getInfieldsForTask(codeGen, t);
 118             final List<ST> outfields = getOutfieldsForTask(codeGen, t);
 119             final ST logic = getLogicForTask(codeGen, t);
 120             final List<ST> parameters = getParametersForTask(codeGen, t);
 121             final List<ST> contextRefs = getCtxtRefsForTask(codeGen, t);
 122
 123             codeGen.addTaskDeclaration(
 124                     new TaskDeclarationBuilder().setName(kig.getName(key)).setVersion(kig.getVersion(key))
 125                             .setUuid(kig.getUuid(key)).setDescription(kig.getDesc(key)).setInfields(infields)
 126                             .setOutfields(outfields).setLogic(logic).setParameters(parameters)
 127                             .setContextRefs(contextRefs));
 128         }
 129
 130         // 3: events
 131         for (final AxEvent e : policyModel.getEvents().getEventMap().values()) {
 132             final AxArtifactKey key = e.getKey();
 133             final List<ST> fields = getParametersForEvent(codeGen, e);
 134
 135             codeGen.addEventDeclaration(
 136                     new EventDeclarationBuilder()
 137                             .setName(kig.getName(key))
 138                             .setVersion(kig.getVersion(key))
 139                             .setUuid(kig.getUuid(key))
 140                             .setDescription(kig.getDesc(key))
 141                             .setNameSpace(e.getNameSpace())
 142                             .setSource(e.getSource())
 143                             .setTarget(e.getTarget())
 144                             .setFields(fields));
 145         }
 146
 147         // 4: context albums
 148         for (final AxContextAlbum a : policyModel.getAlbums().getAlbumsMap().values()) {
 149             final AxArtifactKey key = a.getKey();
 150
 151             codeGen.addContextAlbumDeclaration(
 152                     new CodeGenCliEditorBuilder()
 153                             .setName(kig.getName(key))
 154                             .setVersion(kig.getVersion(key))
 155                             .setUuid(kig.getUuid(key))
 156                             .setDescription(kig.getDesc(key))
 157                             .setScope(a.getScope())
 158                             .setWritable(a.isWritable())
 159                             .setSchemaName(kig.getName(a.getItemSchema()))
 160                             .setSchemaVersion(kig.getVersion(a.getItemSchema())));
 161         }
 162
 163         // 5: policies
 164         for (final AxPolicy p : policyModel.getPolicies().getPolicyMap().values()) {
 165             final AxArtifactKey key = p.getKey();
 166             final List<ST> states = getStatesForPolicy(codeGen, p);
 167             codeGen.addPolicyDefinition(kig.getName(key), kig.getVersion(key), kig.getUuid(key), kig.getDesc(key),
 168                             p.getTemplate(), p.getFirstState(), states);
 169         }
 170
 171         final String out = codeGen.getModel().render();
 172
 173         FileWriter outFileWriter = new FileWriter(outFile);
 174         outFileWriter.write(out);
 175         outFileWriter.close();
 176
 177         return 0;
 178     }
 179
 180     /**
 181      * Gets the parameters for event.
 182      *
 183      * @param cg the code generator
 184      * @param event the event
 185      * @return the parameters for event
 186      */
 187     private List<ST> getParametersForEvent(final CodeGeneratorCliEditor cg, final AxEvent event) {
 188         final Collection<AxField> fields = event.getFields();
 189         final List<ST> ret = new ArrayList<>(fields.size());
 190         for (final AxField f : fields) {
 191             final AxReferenceKey fkey = f.getKey();
 192
 193             final ST val = cg.createEventFieldDefinition(kig.getPName(fkey), kig.getPVersion(fkey), kig.getLName(fkey),
 194                             kig.getName(f.getSchema()), kig.getVersion(f.getSchema()), f.getOptional());
 195
 196             ret.add(val);
 197         }
 198         return ret;
 199     }
 200
 201     /**
 202      * Gets the context references for task.
 203      *
 204      * @param cg the code generator
 205      * @param task the task
 206      * @return the context references for task
 207      */
 208     private List<ST> getCtxtRefsForTask(final CodeGeneratorCliEditor cg, final AxTask task) {
 209         final Collection<AxArtifactKey> ctxs = task.getContextAlbumReferences();
 210         final List<ST> ret = new ArrayList<>(ctxs.size());
 211         final AxArtifactKey tkey = task.getKey();
 212         for (final AxArtifactKey ckey : ctxs) {
 213
 214             final ST val = cg.createTaskDefinitionContextRef(kig.getName(tkey), kig.getVersion(tkey), kig.getName(ckey),
 215                             kig.getVersion(ckey));
 216
 217             ret.add(val);
 218         }
 219         return ret;
 220     }
 221
 222     /**
 223      * Gets the parameters for task.
 224      *
 225      * @param cg the code generator
 226      * @param task the task
 227      * @return the parameters for task
 228      */
 229     private List<ST> getParametersForTask(final CodeGeneratorCliEditor cg, final AxTask task) {
 230         final Collection<AxTaskParameter> pars = task.getTaskParameters().values();
 231         final List<ST> ret = new ArrayList<>(pars.size());
 232         for (final AxTaskParameter p : pars) {
 233             final AxReferenceKey pkey = p.getKey();
 234
 235             final ST val = cg.createTaskDefinitionParameters(kig.getPName(pkey), kig.getPVersion(pkey),
 236                             kig.getLName(pkey), p.getTaskParameterValue());
 237
 238             ret.add(val);
 239         }
 240         return ret;
 241     }
 242
 243     /**
 244      * Gets the logic for task.
 245      *
 246      * @param cg the code generator
 247      * @param task the task
 248      * @return the logic for task
 249      */
 250     private ST getLogicForTask(final CodeGeneratorCliEditor cg, final AxTask task) {
 251         final AxArtifactKey tkey = task.getKey();
 252         final AxTaskLogic tl = task.getTaskLogic();
 253
 254         return cg.createTaskDefLogic(kig.getName(tkey), kig.getVersion(tkey), tl.getLogicFlavour(), tl.getLogic());
 255     }
 256
 257     /**
 258      * Gets the output fields for task.
 259      *
 260      * @param cg the code generator
 261      * @param task the task
 262      * @return the output fields for task
 263      */
 264     private List<ST> getOutfieldsForTask(final CodeGeneratorCliEditor cg, final AxTask task) {
 265         final Collection<? extends AxField> fields = task.getOutputFields().values();
 266         final List<ST> ret = new ArrayList<>(fields.size());
 267         for (final AxField f : fields) {
 268             final AxReferenceKey fkey = f.getKey();
 269
 270             final ST val = cg.createTaskDefinitionOutfields(kig.getPName(fkey), kig.getPVersion(fkey),
 271                             kig.getLName(fkey), kig.getName(f.getSchema()), kig.getVersion(f.getSchema()));
 272
 273             ret.add(val);
 274         }
 275         return ret;
 276     }
 277
 278     /**
 279      * Gets the input fields for task.
 280      *
 281      * @param cg the code generator
 282      * @param task the task
 283      * @return the input fields for task
 284      */
 285     private List<ST> getInfieldsForTask(final CodeGeneratorCliEditor cg, final AxTask task) {
 286         final Collection<? extends AxField> fields = task.getInputFields().values();
 287         final List<ST> ret = new ArrayList<>(fields.size());
 288         for (final AxField f : fields) {
 289             final AxReferenceKey fkey = f.getKey();
 290
 291             final ST val = cg.createTaskDefinitionInfields(kig.getPName(fkey), kig.getPVersion(fkey),
 292                             kig.getLName(fkey), kig.getName(f.getSchema()), kig.getVersion(f.getSchema()));
 293
 294             ret.add(val);
 295         }
 296         return ret;
 297     }
 298
 299     /**
 300      * Gets the states for policy.
 301      *
 302      * @param cg the code generator
 303      * @param pol the policy
 304      * @return the states for policy
 305      */
 306     private List<ST> getStatesForPolicy(final CodeGeneratorCliEditor cg, final AxPolicy pol) {
 307         final Collection<AxState> states = pol.getStateMap().values();
 308         final List<ST> ret = new ArrayList<>(states.size());
 309         for (final AxState st : states) {
 310             final AxReferenceKey skey = st.getKey();
 311             final List<ST> outputs = getStateOutputsForState(cg, st);
 312             final List<ST> finalizerLogics = getFinalizersForState(cg, st);
 313             final List<ST> tasks = getTaskRefsForState(cg, st);
 314             final List<ST> tsLogic = getTslForState(cg, st);
 315             final List<ST> ctxRefs = getCtxtRefsForState(cg, st);
 316
 317             final ST val = cg.createPolicyStateDef(new PolicyStateDefBuilder()
 318                     .setPolicyName(kig.getPName(skey)).setVersion(kig.getPVersion(skey))
 319                     .setStateName(kig.getLName(skey)).setTriggerName(kig.getName(st.getTrigger()))
 320                     .setTriggerVersion(kig.getVersion(st.getTrigger()))
 321                     .setDefaultTask(kig.getName(st.getDefaultTask()))
 322                     .setDefaultTaskVersion(kig.getVersion(st.getDefaultTask())).setOutputs(outputs)
 323                     .setTasks(tasks).setTsLogic(tsLogic).setFinalizerLogics(finalizerLogics)
 324                     .setCtxRefs(ctxRefs));
 325
 326             ret.add(val);
 327         }
 328         return ret;
 329     }
 330
 331     /**
 332      * Gets the finalizers for state.
 333      *
 334      * @param cg the code generator
 335      * @param st the state
 336      * @return the finalizers for state
 337      */
 338     private List<ST> getFinalizersForState(final CodeGeneratorCliEditor cg, final AxState st) {
 339         final Collection<AxStateFinalizerLogic> fins = st.getStateFinalizerLogicMap().values();
 340         final List<ST> ret = new ArrayList<>(fins.size());
 341         final AxReferenceKey skey = st.getKey();
 342         for (final AxStateFinalizerLogic fin : fins) {
 343             final AxReferenceKey finkey = fin.getKey();
 344
 345             final ST val = cg.createPolicyStateDefFinalizerLogic(kig.getPName(skey), kig.getPVersion(skey),
 346                             kig.getLName(skey), kig.getLName(finkey), fin.getLogicFlavour(), fin.getLogic());
 347
 348             ret.add(val);
 349         }
 350         return ret;
 351     }
 352
 353     /**
 354      * Gets the context references for state.
 355      *
 356      * @param cg the code generator
 357      * @param st the state
 358      * @return the context references for state
 359      */
 360     private List<ST> getCtxtRefsForState(final CodeGeneratorCliEditor cg, final AxState st) {
 361         final Collection<AxArtifactKey> ctxs = st.getContextAlbumReferences();
 362         final List<ST> ret = new ArrayList<>(ctxs.size());
 363         final AxReferenceKey skey = st.getKey();
 364         for (final AxArtifactKey ctx : ctxs) {
 365
 366             final ST val = cg.createPolicyStateDefContextRef(kig.getPName(skey), kig.getPVersion(skey),
 367                             kig.getLName(skey), kig.getName(ctx), kig.getVersion(ctx));
 368
 369             ret.add(val);
 370         }
 371         return ret;
 372     }
 373
 374     /**
 375      * Gets the Task Selection Logic for state.
 376      *
 377      * @param cg the code generator
 378      * @param st the state
 379      * @return the TSL for state (if any) in a list
 380      */
 381     private List<ST> getTslForState(final CodeGeneratorCliEditor cg, final AxState st) {
 382         final AxReferenceKey skey = st.getKey();
 383         if (st.checkSetTaskSelectionLogic()) {
 384             final AxTaskSelectionLogic tsl = st.getTaskSelectionLogic();
 385             final ST val = cg.createPolicyStateDefTaskSelLogic(kig.getPName(skey), kig.getPVersion(skey),
 386                             kig.getLName(skey), tsl.getLogicFlavour(), tsl.getLogic());
 387             return Collections.singletonList(val);
 388         } else {
 389             return Collections.emptyList();
 390         }
 391     }
 392
 393     /**
 394      * Gets the task references for state.
 395      *
 396      * @param cg the code generator
 397      * @param st the state
 398      * @return the task references for state
 399      */
 400     private List<ST> getTaskRefsForState(final CodeGeneratorCliEditor cg, final AxState st) {
 401         final Map<AxArtifactKey, AxStateTaskReference> taskrefs = st.getTaskReferences();
 402         final List<ST> ret = new ArrayList<>(taskrefs.size());
 403         final AxReferenceKey skey = st.getKey();
 404         for (final Entry<AxArtifactKey, AxStateTaskReference> e : taskrefs.entrySet()) {
 405             final AxArtifactKey tkey = e.getKey();
 406             final AxStateTaskReference tr = e.getValue();
 407             final AxReferenceKey trkey = tr.getKey();
 408
 409             final ST val = cg.createPolicyStateTask(new PolicyStateTaskBuilder()
 410                     .setPolicyName(kig.getPName(skey)).setVersion(kig.getPVersion(skey))
 411                     .setStateName(kig.getLName(skey)).setTaskLocalName(kig.getLName(trkey))
 412                     .setTaskName(kig.getName(tkey)).setTaskVersion(kig.getVersion(tkey))
 413                     .setOutputType(tr.getStateTaskOutputType().name())
 414                     .setOutputName(kig.getLName(tr.getOutput())));
 415
 416             ret.add(val);
 417         }
 418         return ret;
 419     }
 420
 421     /**
 422      * Gets the state outputs for state.
 423      *
 424      * @param cg the code generator
 425      * @param st the state
 426      * @return the state outputs for state
 427      */
 428     private List<ST> getStateOutputsForState(final CodeGeneratorCliEditor cg, final AxState st) {
 429         final Collection<AxStateOutput> outs = st.getStateOutputs().values();
 430         final List<ST> ret = new ArrayList<>(outs.size());
 431         final AxReferenceKey skey = st.getKey();
 432         for (final AxStateOutput out : outs) {
 433             final AxReferenceKey outkey = out.getKey();
 434
 435             final ST val = cg.createPolicyStateOutput(kig.getPName(skey), kig.getPVersion(skey), kig.getLName(skey),
 436                             kig.getLName(outkey), kig.getName(out.getOutgingEvent()),
 437                             kig.getVersion(out.getOutgingEvent()), kig.getLName(out.getNextState()));
 438
 439             ret.add(val);
 440         }
 441         return ret;
 442     }
 443
 444 }