models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/concepts/JpaPdpPolicyStatusTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
   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.models.pdp.persistence.concepts;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNotEquals;
  27
  28 import java.util.List;
  29 import java.util.function.Consumer;
  30 import java.util.function.UnaryOperator;
  31 import org.assertj.core.api.AbstractStringAssert;
  32 import org.junit.Before;
  33 import org.junit.Test;
  34 import org.onap.policy.models.base.PfKey;
  35 import org.onap.policy.models.base.PfReferenceKey;
  36 import org.onap.policy.models.base.Validated;
  37 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  38 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
  39 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
  40 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  41
  42 public class JpaPdpPolicyStatusTest {
  43     private static final String MY_PDP = "MyPdp";
  44     private static final String MY_GROUP = "MyGroup";
  45     private static final String MY_PDP_TYPE = "MyPdpType";
  46     private static final ToscaConceptIdentifier POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
  47     private static final ToscaConceptIdentifier POLICY_TYPE = new ToscaConceptIdentifier("MyPolicyType", "1.2.4");
  48
  49     private PdpPolicyStatusBuilder builder;
  50
  51
  52     /**
  53      * Set up Policy Status builder.
  54      */
  55     @Before
  56     public void setup() {
  57         // @formatter:off
  58         builder = PdpPolicyStatus.builder()
  59                         .deploy(true)
  60                         .pdpGroup(MY_GROUP)
  61                         .pdpId(MY_PDP)
  62                         .pdpType(MY_PDP_TYPE)
  63                         .policy(POLICY)
  64                         .policyType(POLICY_TYPE)
  65                         .state(State.SUCCESS);
  66         // @formatter:on
  67     }
  68
  69     @Test
  70     public void testJpaPdpPolicyStatus() {
  71         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus();
  72
  73         assertThat(jpa.getKey()).isNotNull();
  74         assertThat(jpa.getKey().isNullKey()).isTrue();
  75         assertThat(jpa.getPdpGroup()).isEqualTo(PfKey.NULL_KEY_NAME);
  76         assertThat(jpa.getPdpType()).isEqualTo(PfKey.NULL_KEY_NAME);
  77         assertThat(jpa.getPolicyType()).isNotNull();
  78         assertThat(jpa.getPolicyType().isNullKey()).isTrue();
  79         assertThat(jpa.isDeploy()).isFalse();
  80         assertThat(jpa.getState()).isEqualTo(State.WAITING);
  81     }
  82
  83     @Test
  84     public void testJpaPdpPolicyStatusJpaPdpPolicyStatus() {
  85         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
  86
  87         assertThat(new JpaPdpPolicyStatus(jpa)).isEqualTo(jpa);
  88     }
  89
  90     @Test
  91     public void testJpaPdpPolicyStatusPdpPolicyStatus() {
  92         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
  93
  94         assertThat(jpa.getKey()).isNotNull();
  95         PfReferenceKey key = jpa.getKey();
  96         assertThat(key.getParentKeyName()).isEqualTo(POLICY.getName());
  97         assertThat(key.getParentKeyVersion()).isEqualTo(POLICY.getVersion());
  98         assertThat(key.getParentLocalName()).isEqualTo(PfKey.NULL_KEY_NAME);
  99         assertThat(key.getLocalName()).isEqualTo(MY_PDP);
 100
 101         assertThat(jpa.getPdpGroup()).isEqualTo(MY_GROUP);
 102         assertThat(jpa.getPdpType()).isEqualTo(MY_PDP_TYPE);
 103
 104         assertThat(jpa.getPolicyType()).isNotNull();
 105         assertThat(jpa.getPolicyType().getName()).isEqualTo(POLICY_TYPE.getName());
 106         assertThat(jpa.getPolicyType().getVersion()).isEqualTo(POLICY_TYPE.getVersion());
 107
 108         assertThat(jpa.isDeploy()).isTrue();
 109         assertThat(jpa.getState()).isEqualTo(State.SUCCESS);
 110     }
 111
 112     @Test
 113     public void testGetKeys() {
 114         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
 115
 116         assertThat(jpa.getKeys()).isEqualTo(List.of(jpa.getKey()));
 117     }
 118
 119     @Test
 120     public void testClean() {
 121         JpaPdpPolicyStatus jpa =
 122                         new JpaPdpPolicyStatus(builder.pdpGroup(MY_GROUP + " ").pdpType(MY_PDP_TYPE + " ").build());
 123
 124         jpa.clean();
 125
 126         assertThat(jpa.getPdpGroup()).isEqualTo(MY_GROUP);
 127         assertThat(jpa.getPdpType()).isEqualTo(MY_PDP_TYPE);
 128     }
 129
 130     @Test
 131     @SuppressWarnings("serial")
 132     public void testCompareTo() {
 133         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
 134
 135         assertNotEquals(0, jpa.compareTo(null));
 136         assertEquals(0, jpa.compareTo(jpa));
 137         assertNotEquals(0, jpa.compareTo(new JpaPdpPolicyStatus(builder.build()) {}));
 138
 139         assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpId("AnotherPdp")));
 140         assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpGroup("AnotherGroup")));
 141         assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpType("AnotherType")));
 142         assertNotEquals(0, checkCompareTo(
 143             bldr -> bldr.policyType(new ToscaConceptIdentifier("AnotherPolicyType", "1.2.4"))));
 144         assertNotEquals(0, checkCompareTo(bldr -> bldr.deploy(false)));
 145         assertNotEquals(0, checkCompareTo(bldr -> bldr.state(State.FAILURE)));
 146     }
 147
 148     private int checkCompareTo(UnaryOperator<PdpPolicyStatusBuilder> fieldModifier) {
 149         JpaPdpPolicyStatus jpa1 = new JpaPdpPolicyStatus(builder.build());
 150         JpaPdpPolicyStatus jpa2 = new JpaPdpPolicyStatus(fieldModifier.apply(builder).build());
 151
 152         return jpa1.compareTo(jpa2);
 153     }
 154
 155     @Test
 156     public void testToAuthorative() {
 157         PdpPolicyStatus data = builder.build();
 158
 159         assertThat(new JpaPdpPolicyStatus(data).toAuthorative()).isEqualTo(data);
 160     }
 161
 162     @Test
 163     public void testFromAuthorative() {
 164         PdpPolicyStatus data = builder.build();
 165         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus();
 166
 167         jpa.fromAuthorative(data);
 168
 169         assertThat(jpa).isEqualTo(new JpaPdpPolicyStatus(data));
 170     }
 171
 172     @Test
 173     public void testValidate() {
 174         assertThat(new JpaPdpPolicyStatus(builder.build()).validate("").getResult()).isNull();
 175
 176         assertThatThrownBy(() -> new JpaPdpPolicyStatus(builder.build()).validate(null))
 177                         .hasMessageContaining("fieldName").hasMessageContaining("is null");
 178
 179         checkValidate(jpa -> jpa.getKey().setParentKeyName(PfKey.NULL_KEY_NAME)).contains("policy name",
 180                         Validated.IS_NULL);
 181
 182         checkValidate(jpa -> jpa.getKey().setParentKeyVersion(PfKey.NULL_KEY_VERSION)).contains("policy version",
 183                         Validated.IS_NULL);
 184
 185         checkValidate(jpa -> jpa.getKey().setParentLocalName("SomeName")).contains("parent local name", "must be NULL");
 186
 187         checkValidate(jpa -> jpa.getKey().setLocalName(PfKey.NULL_KEY_NAME)).contains("pdpId", Validated.IS_NULL);
 188     }
 189
 190     private AbstractStringAssert<?> checkValidate(Consumer<JpaPdpPolicyStatus> fieldModifier) {
 191         JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
 192         fieldModifier.accept(jpa);
 193
 194         return assertThat(jpa.validate("").getResult());
 195     }
 196 }