/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2021 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
assertNotNull(new JpaPdpGroup((new PfConceptKey())));
assertNotNull(new JpaPdpGroup((new JpaPdpGroup())));
+ }
+ @Test
+ public void testPdpGroupSet() {
PdpGroup testPdpGroup = new PdpGroup();
testPdpGroup.setName(PDP_GROUP0);
testPdpGroup.setPdpSubgroups(new ArrayList<>());
- JpaPdpGroup testJpaPdpGroup = new JpaPdpGroup();
- testJpaPdpGroup.setKey(null);
- testJpaPdpGroup.setKey(new PfConceptKey());
-
- testPdpGroup.setVersion(VERSION);
- testJpaPdpGroup.fromAuthorative(testPdpGroup);
+ JpaPdpGroup testJpaPdpGroup = setUpSmallJpaPdpGroup();
assertEquals(PDP_GROUP0, testJpaPdpGroup.getKey().getName());
- testJpaPdpGroup.setKey(PfConceptKey.getNullKey());
- testJpaPdpGroup.fromAuthorative(testPdpGroup);
assertThatThrownBy(() -> {
testJpaPdpGroup.fromAuthorative(null);
testJpaPdpGroup.clean();
assertEquals(PDP_GROUP0, testJpaPdpGroup.getKey().getName());
+ }
+
+ @Test
+ public void testPdpGroupValidation() {
+ JpaPdpGroup testJpaPdpGroup = setUpSmallJpaPdpGroup();
assertThatThrownBy(() -> {
testJpaPdpGroup.validate(null);
assertFalse(testJpaPdpGroup.validate("").isValid());
testJpaPdpGroup.getProperties().remove("NullKey");
assertTrue(testJpaPdpGroup.validate("").isValid());
+ }
+
+ @Test
+ public void testPdpSubgroups() {
+ JpaPdpGroup testJpaPdpGroup = setUpJpaPdpGroup();
List<JpaPdpSubGroup> jpaPdpSubgroups = testJpaPdpGroup.getPdpSubGroups();
assertNotNull(jpaPdpSubgroups);
psg = testJpaPdpGroup.toAuthorative();
assertNull(psg.getProperties());
testJpaPdpGroup.setProperties(new LinkedHashMap<>());
+ }
+
+ @Test
+ public void testPdpGroupsProperties() {
+ JpaPdpGroup testJpaPdpGroup = setUpJpaPdpGroup();
- testJpaPdpGroup.clean();
testJpaPdpGroup.getProperties().put(" PropKey ", " Prop Value ");
testJpaPdpGroup.clean();
assertEquals("PropKey", testJpaPdpGroup.getProperties().keySet().iterator().next());
testJpaPdpGroup.clean();
assertEquals("A Description", testJpaPdpGroup.getDescription());
+ JpaPdpSubGroup anotherPdpSubgroup =
+ new JpaPdpSubGroup(new PfReferenceKey(testJpaPdpGroup.getKey(), "AnotherPdpSubgroup"));
+
assertEquals(1, testJpaPdpGroup.getKeys().size());
testJpaPdpGroup.getPdpSubGroups().add(anotherPdpSubgroup);
assertEquals(2, testJpaPdpGroup.getKeys().size());
assertEquals(testJpaPdpGroup, new JpaPdpGroup(testJpaPdpGroup));
}
+
+ private JpaPdpGroup setUpSmallJpaPdpGroup() {
+ PdpGroup testPdpGroup = new PdpGroup();
+ testPdpGroup.setName(PDP_GROUP0);
+ testPdpGroup.setPdpSubgroups(new ArrayList<>());
+ testPdpGroup.setVersion(VERSION);
+
+ JpaPdpGroup testJpaPdpGroup = new JpaPdpGroup();
+ testJpaPdpGroup.setKey(new PfConceptKey(PDP_GROUP0, VERSION));
+ testJpaPdpGroup.fromAuthorative(testPdpGroup);
+ testJpaPdpGroup.clean();
+
+ return testJpaPdpGroup;
+ }
+
+ private JpaPdpGroup setUpJpaPdpGroup() {
+ JpaPdpGroup testJpaPdpGroup = setUpSmallJpaPdpGroup();
+
+ testJpaPdpGroup.setKey(new PfConceptKey("PdpGroup0", VERSION));
+ testJpaPdpGroup.setDescription(null);
+ testJpaPdpGroup.setPdpGroupState(PdpState.PASSIVE);
+ testJpaPdpGroup.setProperties(new LinkedHashMap<>());
+ testJpaPdpGroup.clean();
+
+ return testJpaPdpGroup;
+ }
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2021 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
private static final String PDP_A = "PDP-A";
@Test
- public void testJpaPdpSubGroup() {
+ public void testJpaPdpSubGroupErrors() {
assertThatThrownBy(() -> {
new JpaPdpSubGroup((JpaPdpSubGroup) null);
}).hasMessageMatching("copyConcept is marked .*ull but is null");
}).hasMessageMatching(NULL_KEY_ERROR);
assertNotNull(new JpaPdpSubGroup((new PfReferenceKey())));
+ }
+ @Test
+ public void testJpaPdpSubGroup() {
PdpSubGroup testPdpSubgroup = new PdpSubGroup();
testPdpSubgroup.setPdpType(PDP_A);
JpaPdpSubGroup testJpaPdpSubGroup = new JpaPdpSubGroup();
testJpaPdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
testJpaPdpSubGroup.getSupportedPolicyTypes().add(new PfSearchableKey("APolicyType:1.0.0"));
assertTrue(testJpaPdpSubGroup.validate("").isValid());
+ }
+
+ @Test
+ public void testJpaPdpSubGroupSavedKey() {
+ JpaPdpSubGroup testJpaPdpSubGroup = setUpJpaPdpSubGroup();
PfReferenceKey savedKey = testJpaPdpSubGroup.getKey();
testJpaPdpSubGroup.setKey(PfReferenceKey.getNullKey());
assertTrue(testJpaPdpSubGroup.validate("").isValid());
testJpaPdpSubGroup.setProperties(null);
assertTrue(testJpaPdpSubGroup.validate("").isValid());
+ }
+
+ @Test
+ public void testJpaPdpSubGroupPolicyTypes() {
+ JpaPdpSubGroup testJpaPdpSubGroup = setUpJpaPdpSubGroup();
List<PfSearchableKey> supportedPolicyTypes = testJpaPdpSubGroup.getSupportedPolicyTypes();
assertNotNull(supportedPolicyTypes);
assertTrue(testJpaPdpSubGroup.validate("").isValid());
testJpaPdpSubGroup.setPdpInstances(pdpInstances);
assertTrue(testJpaPdpSubGroup.validate("").isValid());
+ }
+
+ @Test
+ public void testJpaPdpSubGroupKeys() {
+ JpaPdpSubGroup testJpaPdpSubGroup = setUpJpaPdpSubGroup();
JpaPdpSubGroup otherJpaPdpSubGroup = new JpaPdpSubGroup(testJpaPdpSubGroup);
assertEquals(0, testJpaPdpSubGroup.compareTo(otherJpaPdpSubGroup));
assertEquals(testJpaPdpSubGroup, new JpaPdpSubGroup(testJpaPdpSubGroup));
}
+
+ private JpaPdpSubGroup setUpJpaPdpSubGroup() {
+ PdpSubGroup testPdpSubgroup = new PdpSubGroup();
+ testPdpSubgroup.setPdpType(PDP_A);
+ JpaPdpSubGroup testJpaPdpSubGroup = new JpaPdpSubGroup();
+ testJpaPdpSubGroup.setKey(PfReferenceKey.getNullKey());
+ testJpaPdpSubGroup.fromAuthorative(testPdpSubgroup);
+ testJpaPdpSubGroup.getKey().setParentConceptKey(new PfConceptKey("Parent:1.0.0"));
+ testJpaPdpSubGroup.setProperties(new LinkedHashMap<>());
+ testJpaPdpSubGroup.setDesiredInstanceCount(0);
+ testJpaPdpSubGroup.setCurrentInstanceCount(0);
+ testJpaPdpSubGroup.setProperties(null);
+ testJpaPdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
+ testJpaPdpSubGroup.getSupportedPolicyTypes().add(new PfSearchableKey("APolicyType:1.0.0"));
+ testJpaPdpSubGroup.clean();
+ return testJpaPdpSubGroup;
+ }
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2021 Nordix Foundation.
* Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
}).hasMessageMatching("authorativeConcept is marked .*ull but is null");
assertNotNull(new JpaPdp((new PfReferenceKey())));
+ }
+ @Test
+ public void testJpaPdpInstace() {
Pdp testPdp = new Pdp();
testPdp.setInstanceId(PDP1);
JpaPdp testJpaPdp = new JpaPdp();
testJpaPdp.setMessage(" A Message ");
testJpaPdp.clean();
assertEquals("A Message", testJpaPdp.getMessage());
+ }
+
+ @Test
+ public void testJpaPdpValidation() {
+ Pdp testPdp = new Pdp();
+ testPdp.setInstanceId(PDP1);
+ JpaPdp testJpaPdp = new JpaPdp();
+ testJpaPdp.setKey(PfReferenceKey.getNullKey());
+ testJpaPdp.fromAuthorative(testPdp);
assertThatThrownBy(() -> {
testJpaPdp.validate(null);
testJpaPdp.setHealthy(PdpHealthStatus.HEALTHY);
assertTrue(testJpaPdp.validate("").isValid());
+ }
+
+ @Test
+ public void testJpaPdpValidationSwapKey() {
+ JpaPdp testJpaPdp = setUpJpaPdp();
PfReferenceKey savedKey = testJpaPdp.getKey();
testJpaPdp.setKey(PfReferenceKey.getNullKey());
assertFalse(testJpaPdp.validate("").isValid());
testJpaPdp.setMessage("Valid Message");
assertTrue(testJpaPdp.validate("").isValid());
+ }
+
+ @Test
+ public void testJpaPdpCompare() {
+ JpaPdp testJpaPdp = setUpJpaPdp();
JpaPdp otherJpaPdp = new JpaPdp(testJpaPdp);
assertEquals(0, testJpaPdp.compareTo(otherJpaPdp));
assertEquals(testJpaPdp, new JpaPdp(testJpaPdp));
}
+
+ private JpaPdp setUpJpaPdp() {
+ Pdp testPdp = new Pdp();
+ testPdp.setInstanceId(PDP1);
+ JpaPdp testJpaPdp = new JpaPdp();
+ testJpaPdp.setKey(PfReferenceKey.getNullKey());
+ testJpaPdp.fromAuthorative(testPdp);
+ testJpaPdp.getKey().setParentConceptKey(new PfConceptKey("Parent:1.0.0"));
+ testJpaPdp.getKey().setParentLocalName("ParentLocal");
+ testJpaPdp.setPdpState(PdpState.ACTIVE);
+ testJpaPdp.setHealthy(PdpHealthStatus.HEALTHY);
+ testJpaPdp.setMessage("Valid Message");
+ return testJpaPdp;
+ }
}
}
@Test
- public void testUpdatePdpStatistics() throws PfModelException {
+ public void testUpdatePdpStatisticsDao() throws PfModelException {
assertThatThrownBy(() -> {
new PdpProvider().updatePdpStatistics(null, null, null, null, null);
}).hasMessageMatching(DAO_IS_NULL);
assertThatThrownBy(() -> {
new PdpProvider().updatePdpStatistics(null, "name", "TYPE", "inst", new PdpStatistics());
}).hasMessageMatching(DAO_IS_NULL);
+ }
+ @Test
+ public void testUpdatePdpStatisticsGroup() throws PfModelException {
assertThatThrownBy(() -> {
new PdpProvider().updatePdpStatistics(pfDao, null, null, null, null);
}).hasMessageMatching(GROUP_IS_NULL);