2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2020 Nordix Foundation.
4 * Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * SPDX-License-Identifier: Apache-2.0
19 * ============LICENSE_END=========================================================
22 package org.onap.policy.models.base;
24 import static org.assertj.core.api.Assertions.assertThat;
25 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertFalse;
29 import static org.junit.Assert.assertNotEquals;
30 import static org.junit.Assert.assertNotNull;
31 import static org.junit.Assert.assertTrue;
33 import java.lang.reflect.Field;
34 import lombok.EqualsAndHashCode;
36 import lombok.NoArgsConstructor;
38 import org.junit.Test;
39 import org.onap.policy.common.parameters.ValidationResult;
40 import org.onap.policy.models.base.PfKey.Compatibility;
41 import org.onap.policy.models.base.testconcepts.DummyPfKey;
43 public class PfKeyImplTest {
45 private static final String OTHER_IS_NULL = "^otherKey is marked .*on.*ull but is null$";
46 private static final String ID_IS_NULL = "^id is marked .*on.*ull but is null$";
47 private static final String VERSION123 = "1.2.3";
48 private static final String VERSION100 = "1.0.0";
49 private static final String VERSION001 = "0.0.1";
52 public void testConceptKey() {
53 assertThatIllegalArgumentException().isThrownBy(() -> new MyKey("some bad key id"))
54 .withMessage("parameter \"id\": value \"some bad key id\", " + "does not match regular expression \""
55 + PfKey.KEY_ID_REGEXP + "\"");
57 assertThatThrownBy(() -> new MyKey((MyKey) null))
58 .hasMessageMatching("^copyConcept is marked .*on.*ull but is null$");
60 MyKey someKey0 = new MyKey();
61 assertTrue(someKey0.isNullKey());
62 assertEquals(new MyKey(PfKey.NULL_KEY_NAME, PfKey.NULL_KEY_VERSION), someKey0);
64 MyKey someKey1 = new MyKey("name", VERSION001);
65 MyKey someKey2 = new MyKey(someKey1);
66 MyKey someKey3 = new MyKey(someKey1.getId());
67 assertEquals(someKey1, someKey2);
68 assertEquals(someKey1, someKey3);
69 assertFalse(someKey1.isNullKey());
70 assertFalse(someKey1.isNullVersion());
72 assertEquals(someKey2, someKey1.getKey());
73 assertEquals(1, someKey1.getKeys().size());
75 someKey0.setName("zero");
76 someKey0.setVersion("0.0.2");
78 someKey3.setVersion("0.0.2");
80 MyKey someKey4 = new MyKey(someKey1);
81 someKey4.setVersion("0.1.2");
83 MyKey someKey4a = new MyKey(someKey1);
84 someKey4a.setVersion("0.0.0");
86 MyKey someKey5 = new MyKey(someKey1);
87 someKey5.setVersion("1.2.2");
89 MyKey someKey6 = new MyKey(someKey1);
90 someKey6.setVersion("3.0.0");
92 assertEquals("name:0.1.2", someKey4.getId());
94 assertThatThrownBy(() -> someKey0.getCompatibility(null)).isInstanceOf(NullPointerException.class)
95 .hasMessageMatching("^otherKey is marked .*on.*ull but is null$");
97 assertEquals(Compatibility.DIFFERENT, someKey0.getCompatibility(new DummyPfKey()));
98 assertEquals(Compatibility.DIFFERENT, someKey0.getCompatibility(someKey1));
99 assertEquals(Compatibility.IDENTICAL, someKey2.getCompatibility(someKey1));
100 assertEquals(Compatibility.PATCH, someKey3.getCompatibility(someKey1));
101 assertEquals(Compatibility.MINOR, someKey4.getCompatibility(someKey1));
102 assertEquals(Compatibility.PATCH, someKey4a.getCompatibility(someKey1));
103 assertEquals(Compatibility.PATCH, someKey1.getCompatibility(someKey4a));
104 assertEquals(Compatibility.MAJOR, someKey5.getCompatibility(someKey1));
105 assertEquals(Compatibility.MAJOR, someKey6.getCompatibility(someKey1));
107 assertTrue(someKey1.isCompatible(someKey2));
108 assertTrue(someKey1.isCompatible(someKey3));
109 assertTrue(someKey1.isCompatible(someKey4));
110 assertFalse(someKey1.isCompatible(someKey0));
111 assertFalse(someKey1.isCompatible(someKey5));
112 assertFalse(someKey1.isCompatible(new DummyPfKey()));
114 assertTrue(someKey0.validate("").isValid());
115 assertTrue(someKey1.validate("").isValid());
116 assertTrue(someKey2.validate("").isValid());
117 assertTrue(someKey3.validate("").isValid());
118 assertTrue(someKey4.validate("").isValid());
119 assertTrue(someKey5.validate("").isValid());
120 assertTrue(someKey6.validate("").isValid());
123 assertNotNull(someKey0.toString());
125 MyKey someKey7 = new MyKey(someKey1);
126 assertEquals(244799191, someKey7.hashCode());
127 assertEquals(0, someKey7.compareTo(someKey1));
128 assertEquals(-12, someKey7.compareTo(someKey0));
130 assertThatThrownBy(() -> someKey0.compareTo(null)).isInstanceOf(NullPointerException.class)
131 .hasMessageMatching("^otherObj is marked .*on.*ull but is null$");
133 assertEquals(0, someKey0.compareTo(someKey0));
134 assertEquals(-36, someKey0.compareTo(new DummyPfKey()));
136 assertNotEquals(someKey0, null);
137 assertEquals(someKey0, (Object) someKey0);
138 assertNotEquals(someKey0, (Object) new DummyPfKey());
140 MyKey someKey8 = new MyKey();
141 someKey8.setVersion(VERSION001);
142 assertFalse(someKey8.isNullKey());
144 someKey8.setVersion("10");
145 assertEquals(0, someKey8.getMinorVersion());
147 someKey8.setVersion("10.11");
148 assertEquals(0, someKey8.getPatchVersion());
152 public void testNullArguments() {
153 assertThatThrownBy(() -> new MyKey((String) null)).hasMessageMatching(ID_IS_NULL);
155 assertThatThrownBy(() -> new MyKey((MyKey) null))
156 .hasMessageMatching("^copyConcept is marked .*on.*ull but is null$");
158 assertThatThrownBy(() -> new MyKey(null, null)).hasMessageMatching("name is marked .*on.*ull but is null$");
160 assertThatThrownBy(() -> new MyKey("name", null))
161 .hasMessageMatching("^version is marked .*on.*ull but is null$");
163 assertThatThrownBy(() -> new MyKey(null, VERSION001))
164 .hasMessageMatching("^name is marked .*on.*ull but is null$");
166 assertThatThrownBy(() -> new MyKey("AKey", VERSION001).isCompatible(null)).hasMessageMatching(OTHER_IS_NULL);
170 public void testValidation() throws Exception {
171 MyKey testKey = new MyKey("TheKey", VERSION001);
172 assertEquals("TheKey:0.0.1", testKey.getId());
174 Field nameField = testKey.getClass().getDeclaredField("name");
175 nameField.setAccessible(true);
176 nameField.set(testKey, "Key Name");
177 ValidationResult validationResult = testKey.validate("");
178 nameField.set(testKey, "TheKey");
179 nameField.setAccessible(false);
180 assertThat(validationResult.getResult()).contains("\"name\"").doesNotContain("\"version\"")
181 .contains("does not match regular expression " + PfKey.NAME_REGEXP);
183 Field versionField = testKey.getClass().getDeclaredField("version");
184 versionField.setAccessible(true);
185 versionField.set(testKey, "Key Version");
186 ValidationResult validationResult2 = testKey.validate("");
187 versionField.set(testKey, VERSION001);
188 versionField.setAccessible(false);
189 assertThat(validationResult2.getResult()).doesNotContain("\"name\"").contains("\"version\"")
190 .contains("does not match regular expression " + PfKey.VERSION_REGEXP);
194 public void testkeynewerThan() {
195 MyKey key1 = new MyKey("Key1", VERSION123);
197 assertThatThrownBy(() -> key1.isNewerThan(null)).hasMessageMatching(OTHER_IS_NULL);
199 assertThatThrownBy(() -> key1.isNewerThan(new PfReferenceKey())).hasMessage(
200 "org.onap.policy.models.base.PfReferenceKey is not " + "an instance of " + PfKeyImpl.class.getName());
202 assertFalse(key1.isNewerThan(key1));
204 MyKey key1a = new MyKey("Key1a", VERSION123);
205 assertFalse(key1.isNewerThan(key1a));
207 MyKey key1b = new MyKey("Key0", VERSION123);
208 assertTrue(key1.isNewerThan(key1b));
210 key1a.setName("Key1");
211 assertFalse(key1.isNewerThan(key1a));
213 key1a.setVersion("0.2.3");
214 assertTrue(key1.isNewerThan(key1a));
215 key1a.setVersion("2.2.3");
216 assertFalse(key1.isNewerThan(key1a));
217 key1a.setVersion(VERSION123);
218 assertFalse(key1.isNewerThan(key1a));
220 key1a.setVersion("1.1.3");
221 assertTrue(key1.isNewerThan(key1a));
222 key1a.setVersion("1.3.3");
223 assertFalse(key1.isNewerThan(key1a));
224 key1a.setVersion(VERSION123);
225 assertFalse(key1.isNewerThan(key1a));
227 key1a.setVersion("1.2.2");
228 assertTrue(key1.isNewerThan(key1a));
229 key1a.setVersion("1.2.4");
230 assertFalse(key1.isNewerThan(key1a));
231 key1a.setVersion(VERSION123);
232 assertFalse(key1.isNewerThan(key1a));
234 key1.setVersion(VERSION100);
235 assertFalse(key1.isNewerThan(key1a));
236 key1a.setVersion(VERSION100);
237 assertFalse(key1.isNewerThan(key1a));
239 PfReferenceKey refKey = new PfReferenceKey();
241 assertThatThrownBy(() -> refKey.isNewerThan(null)).hasMessageMatching(OTHER_IS_NULL);
243 assertThatThrownBy(() -> refKey.isNewerThan(new MyKey()))
244 .hasMessage(MyKey.class.getName() + " is not an instance of " + PfReferenceKey.class.getName());
246 assertFalse(refKey.isNewerThan(refKey));
250 public void testmajorMinorPatch() {
251 MyKey key = new MyKey("Key", VERSION100);
252 assertEquals(1, key.getMajorVersion());
253 assertEquals(0, key.getMinorVersion());
254 assertEquals(0, key.getPatchVersion());
256 key = new MyKey("Key", "1.2.0");
257 assertEquals(1, key.getMajorVersion());
258 assertEquals(2, key.getMinorVersion());
259 assertEquals(0, key.getPatchVersion());
261 key = new MyKey("Key", VERSION123);
262 assertEquals(1, key.getMajorVersion());
263 assertEquals(2, key.getMinorVersion());
264 assertEquals(3, key.getPatchVersion());
269 @EqualsAndHashCode(callSuper = false)
271 private static class MyKey extends PfKeyImpl {
272 private static final long serialVersionUID = 1L;
275 private String version;
277 public MyKey(String name, String version) {
278 super(name, version);
281 public MyKey(String id) {
285 public MyKey(MyKey myKey) {