Link the AutomationComposition with AutomationCompositionDefinition

In AutomationComposition replace the link to ToscaNodeTemplate
whit a link to AutomationCompositionDefinition
using compositionId.

Issue-ID: POLICY-4464
Change-Id: I66878f04ef93fb0754d0066e78bd074ce082f891
Signed-off-by: FrancescoFioraEst <francesco.fiora@est.tech>

4 files changed, 107 insertions, 178 deletions

diff --git a/models/src/test/java/org/onap/policy/clamp/models/acm/concepts/AutomationCompositionTest.java b/models/src/test/java/org/onap/policy/clamp/models/acm/concepts/AutomationCompositionTest.java
index aaa8368d7..e32735f07 100644
--- a/models/src/test/java/org/onap/policy/clamp/models/acm/concepts/AutomationCompositionTest.java
+++ b/models/src/test/java/org/onap/policy/clamp/models/acm/concepts/AutomationCompositionTest.java
@@ -30,16 +30,12 @@ import static org.junit.jupiter.api.Assertions.assertNull;
 import java.util.LinkedHashMap;
 import java.util.UUID;
 import org.junit.jupiter.api.Test;
-import org.onap.policy.models.base.PfKey;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 
 class AutomationCompositionTest {
     @Test
     void testAutomationComposition() {
         var ac0 = new AutomationComposition();
-        ac0.setDefinition(new ToscaConceptIdentifier("dfName", "1.2.3"));
-        assertEquals("dfName", ac0.getType());
-        assertEquals("1.2.3", ac0.getTypeVersion());
+        ac0.setCompositionId(UUID.randomUUID());
 
         var ac1 = new AutomationComposition(ac0);
         assertEquals(ac0, ac1);
@@ -60,7 +56,7 @@ class AutomationCompositionTest {
 
         var ac1 = new AutomationComposition();
 
-        ac1.setDefinition(new ToscaConceptIdentifier("defName", "0.0.1"));
+        ac1.setCompositionId(UUID.randomUUID());
         ac1.setDescription("Description");
         ac1.setElements(new LinkedHashMap<>());
         ac1.setName("Name");
@@ -79,7 +75,7 @@ class AutomationCompositionTest {
         ac2.setElements(new LinkedHashMap<>());
 
         // @formatter:off
-        assertThatThrownBy(() -> ac2.setDefinition(null)).  isInstanceOf(NullPointerException.class);
+        assertThatThrownBy(() -> ac2.setCompositionId(null)).  isInstanceOf(NullPointerException.class);
         assertThatThrownBy(() -> ac2.setOrderedState(null)).isInstanceOf(NullPointerException.class);
         assertThatThrownBy(() -> ac2.setState(null)).       isInstanceOf(NullPointerException.class);
         // @formatter:on
@@ -97,18 +93,5 @@ class AutomationCompositionTest {
 
         assertNull(ac0.getElements().get(UUID.randomUUID()));
         assertNull(ac1.getElements().get(UUID.randomUUID()));
-
-        assertEquals(PfKey.NULL_KEY_NAME, ac0.getDefinition().getName());
-
-    }
-
-    private AutomationCompositionElement getAutomationCompositionElementTest(UUID uuid, ToscaConceptIdentifier id) {
-        var acElement = new AutomationCompositionElement();
-        acElement.setId(uuid);
-        acElement.setParticipantId(id);
-        acElement.setDefinition(id);
-        acElement.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
-
-        return acElement;
     }
 }
diff --git a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionElementTest.java b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionElementTest.java
index 20030e91e..7103f7f7a 100644
--- a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionElementTest.java
+++ b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionElementTest.java
@@ -136,10 +136,10 @@ class JpaAutomationCompositionElementTest {
 
     @Test
     void testJpaAutomationCompositionElement() {
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement =
+        var testJpaAutomationCompositionElement =
             createJpaAutomationCompositionElementInstance();
 
-        AutomationCompositionElement ace = createAutomationCompositionElementInstance();
+        var ace = createAutomationCompositionElementInstance();
         assertEquals(ace, testJpaAutomationCompositionElement.toAuthorative());
 
         assertThatThrownBy(() -> {
@@ -149,7 +149,7 @@ class JpaAutomationCompositionElementTest {
         assertThatThrownBy(() -> new JpaAutomationCompositionElement((JpaAutomationCompositionElement) null))
             .isInstanceOf(NullPointerException.class);
 
-        JpaAutomationCompositionElement testJpaAutomationCompositionElementFa = new JpaAutomationCompositionElement();
+        var testJpaAutomationCompositionElementFa = new JpaAutomationCompositionElement();
         testJpaAutomationCompositionElementFa.setKey(null);
         testJpaAutomationCompositionElementFa.fromAuthorative(ace);
         assertEquals(testJpaAutomationCompositionElement, testJpaAutomationCompositionElementFa);
@@ -177,26 +177,26 @@ class JpaAutomationCompositionElementTest {
         testJpaAutomationCompositionElement.clean();
         assertEquals("A Message", testJpaAutomationCompositionElement.getDescription());
 
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement2 =
+        var testJpaAutomationCompositionElement2 =
             new JpaAutomationCompositionElement(testJpaAutomationCompositionElement);
         assertEquals(testJpaAutomationCompositionElement, testJpaAutomationCompositionElement2);
     }
 
     @Test
     void testJpaAutomationCompositionElementOrderedState() throws CoderException {
-        AutomationCompositionElement testAutomationCompositionElement = createAutomationCompositionElementInstance();
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement =
+        var testAutomationCompositionElement = createAutomationCompositionElementInstance();
+        var testJpaAutomationCompositionElement =
             createJpaAutomationCompositionElementInstance();
 
         testJpaAutomationCompositionElement.setOrderedState(null);
         assertEquals(testAutomationCompositionElement, testJpaAutomationCompositionElement.toAuthorative());
         testJpaAutomationCompositionElement.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
 
-        AutomationCompositionElement noOrderedStateAce = new StandardCoder().decode(
+        var noOrderedStateAce = new StandardCoder().decode(
             new File("src/test/resources/json/AutomationCompositionElementNoOrderedState.json"),
             AutomationCompositionElement.class);
 
-        JpaAutomationCompositionElement noOrderedStateJpaAce = new JpaAutomationCompositionElement(noOrderedStateAce);
+        var noOrderedStateJpaAce = new JpaAutomationCompositionElement(noOrderedStateAce);
         assertNull(noOrderedStateJpaAce.getOrderedState());
         noOrderedStateAce.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
         noOrderedStateJpaAce = new JpaAutomationCompositionElement(noOrderedStateAce);
@@ -205,7 +205,7 @@ class JpaAutomationCompositionElementTest {
 
     @Test
     void testJpaAutomationCompositionElementValidation() {
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement =
+        var testJpaAutomationCompositionElement =
             createJpaAutomationCompositionElementInstance();
 
         assertThatThrownBy(() -> testJpaAutomationCompositionElement.validate(null))
@@ -216,10 +216,10 @@ class JpaAutomationCompositionElementTest {
 
     @Test
     void testJpaAutomationCompositionElementCompareTo() {
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement =
+        var testJpaAutomationCompositionElement =
             createJpaAutomationCompositionElementInstance();
 
-        JpaAutomationCompositionElement otherJpaAutomationCompositionElement =
+        var otherJpaAutomationCompositionElement =
             new JpaAutomationCompositionElement(testJpaAutomationCompositionElement);
         assertEquals(0, testJpaAutomationCompositionElement.compareTo(otherJpaAutomationCompositionElement));
         assertEquals(-1, testJpaAutomationCompositionElement.compareTo(null));
@@ -266,14 +266,14 @@ class JpaAutomationCompositionElementTest {
     @Test
     void testJpaAutomationCompositionElementLombok() {
         assertNotNull(new Participant());
-        JpaAutomationCompositionElement ace0 = new JpaAutomationCompositionElement();
+        var ace0 = new JpaAutomationCompositionElement();
 
         assertThat(ace0.toString()).contains("JpaAutomationCompositionElement(");
         assertThat(ace0.hashCode()).isNotZero();
         assertEquals(ace0, ace0);
         assertNotEquals(null, ace0);
 
-        JpaAutomationCompositionElement ace1 = new JpaAutomationCompositionElement();
+        var ace1 = new JpaAutomationCompositionElement();
 
         ace1.setDefinition(new PfConceptKey("defName", "0.0.1"));
         ace1.setDescription("Description");
@@ -288,13 +288,13 @@ class JpaAutomationCompositionElementTest {
 
         assertNotEquals(ace1, ace0);
 
-        JpaAutomationCompositionElement ace2 = new JpaAutomationCompositionElement();
+        var ace2 = new JpaAutomationCompositionElement();
         assertEquals(ace2, ace0);
     }
 
     private JpaAutomationCompositionElement createJpaAutomationCompositionElementInstance() {
-        AutomationCompositionElement testAce = createAutomationCompositionElementInstance();
-        JpaAutomationCompositionElement testJpaAutomationCompositionElement = new JpaAutomationCompositionElement();
+        var testAce = createAutomationCompositionElementInstance();
+        var testJpaAutomationCompositionElement = new JpaAutomationCompositionElement();
         testJpaAutomationCompositionElement.setKey(null);
         testJpaAutomationCompositionElement.fromAuthorative(testAce);
         testJpaAutomationCompositionElement.setKey(PfReferenceKey.getNullKey());
@@ -304,7 +304,7 @@ class JpaAutomationCompositionElementTest {
     }
 
     private AutomationCompositionElement createAutomationCompositionElementInstance() {
-        AutomationCompositionElement automationCompositionElement = new AutomationCompositionElement();
+        var automationCompositionElement = new AutomationCompositionElement();
         automationCompositionElement.setId(UUID.fromString("a95757ba-b34a-4049-a2a8-46773abcbe5e"));
         automationCompositionElement.setDefinition(new ToscaConceptIdentifier("aceDef", "0.0.1"));
         automationCompositionElement.setParticipantType(new ToscaConceptIdentifier("participantType", "0.0.1"));
diff --git a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionTest.java b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionTest.java
index 4dea5bd13..733ba3807 100644
--- a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionTest.java
+++ b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/concepts/JpaAutomationCompositionTest.java
@@ -24,7 +24,6 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -32,6 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.File;
 import java.util.LinkedHashMap;
+import java.util.UUID;
 import org.junit.jupiter.api.Test;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
@@ -40,7 +40,6 @@ import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
 import org.onap.policy.common.utils.coder.CoderException;
 import org.onap.policy.common.utils.coder.StandardCoder;
 import org.onap.policy.models.base.PfConceptKey;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 
 /**
  * Test the {@link JpaAutomationCompositionTest} class.
@@ -48,6 +47,7 @@ import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 class JpaAutomationCompositionTest {
 
     private static final String NULL_KEY_ERROR = "key is marked .*ull but is null";
+    private static final String COMPOSITION_ID = "709c62b3-8918-41b9-a747-e21eb79c6c41";
 
     @Test
     void testJpaAutomationCompositionConstructor() {
@@ -76,63 +76,61 @@ class JpaAutomationCompositionTest {
         }).hasMessageMatching(NULL_KEY_ERROR);
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(null, new PfConceptKey(), null, null);
+            new JpaAutomationComposition(null, "key", null, null);
         }).hasMessageMatching(NULL_KEY_ERROR);
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(null, new PfConceptKey(), null, new LinkedHashMap<>());
+            new JpaAutomationComposition(null, "key", null, new LinkedHashMap<>());
         }).hasMessageMatching(NULL_KEY_ERROR);
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(null, new PfConceptKey(), AutomationCompositionState.UNINITIALISED, null);
+            new JpaAutomationComposition(null, "key", AutomationCompositionState.UNINITIALISED, null);
         }).hasMessageMatching(NULL_KEY_ERROR);
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(null, new PfConceptKey(), AutomationCompositionState.UNINITIALISED,
-                new LinkedHashMap<>());
+            new JpaAutomationComposition(null, "key", AutomationCompositionState.UNINITIALISED, new LinkedHashMap<>());
         }).hasMessageMatching(NULL_KEY_ERROR);
 
         assertThatThrownBy(() -> {
             new JpaAutomationComposition(new PfConceptKey(), null, null, null);
-        }).hasMessageMatching("definition is marked .*ull but is null");
+        }).hasMessageMatching("compositionId is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
             new JpaAutomationComposition(new PfConceptKey(), null, null, new LinkedHashMap<>());
-        }).hasMessageMatching("definition is marked .*ull but is null");
+        }).hasMessageMatching("compositionId is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
             new JpaAutomationComposition(new PfConceptKey(), null, AutomationCompositionState.UNINITIALISED, null);
-        }).hasMessageMatching("definition is marked .*ull but is null");
+        }).hasMessageMatching("compositionId is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
             new JpaAutomationComposition(new PfConceptKey(), null, AutomationCompositionState.UNINITIALISED,
-                new LinkedHashMap<>());
-        }).hasMessageMatching("definition is marked .*ull but is null");
+                    new LinkedHashMap<>());
+        }).hasMessageMatching("compositionId is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(), null, null);
+            new JpaAutomationComposition(new PfConceptKey(), "key", null, null);
         }).hasMessageMatching("state is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(), null, new LinkedHashMap<>());
+            new JpaAutomationComposition(new PfConceptKey(), "key", null, new LinkedHashMap<>());
         }).hasMessageMatching("state is marked .*ull but is null");
 
         assertThatThrownBy(() -> {
-            new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(),
-                AutomationCompositionState.UNINITIALISED, null);
+            new JpaAutomationComposition(new PfConceptKey(), "key", AutomationCompositionState.UNINITIALISED, null);
         }).hasMessageMatching("elements is marked .*ull but is null");
 
         assertNotNull(new JpaAutomationComposition());
         assertNotNull(new JpaAutomationComposition((new PfConceptKey())));
-        assertNotNull(new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(),
-            AutomationCompositionState.UNINITIALISED, new LinkedHashMap<>()));
+        assertNotNull(new JpaAutomationComposition(new PfConceptKey(), "key", AutomationCompositionState.UNINITIALISED,
+                new LinkedHashMap<>()));
     }
 
     @Test
     void testJpaAutomationComposition() {
-        JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
+        var testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 
-        AutomationComposition participant = createAutomationCompositionInstance();
+        var participant = createAutomationCompositionInstance();
         assertEquals(participant, testJpaAutomationComposition.toAuthorative());
 
         assertThatThrownBy(() -> {
@@ -140,9 +138,9 @@ class JpaAutomationCompositionTest {
         }).hasMessageMatching("automationComposition is marked .*ull but is null");
 
         assertThatThrownBy(() -> new JpaAutomationComposition((JpaAutomationComposition) null))
-            .isInstanceOf(NullPointerException.class);
+                .isInstanceOf(NullPointerException.class);
 
-        JpaAutomationComposition testJpaAutomationCompositionFa = new JpaAutomationComposition();
+        var testJpaAutomationCompositionFa = new JpaAutomationComposition();
         testJpaAutomationCompositionFa.setKey(null);
         testJpaAutomationCompositionFa.fromAuthorative(participant);
         assertEquals(testJpaAutomationComposition, testJpaAutomationCompositionFa);
@@ -155,10 +153,10 @@ class JpaAutomationCompositionTest {
 
         assertEquals("automation-composition", testJpaAutomationComposition.getKey().getName());
         assertEquals("automation-composition",
-            new JpaAutomationComposition(createAutomationCompositionInstance()).getKey().getName());
+                new JpaAutomationComposition(createAutomationCompositionInstance()).getKey().getName());
         assertEquals("automation-composition",
-            ((PfConceptKey) new JpaAutomationComposition(createAutomationCompositionInstance()).getKeys().get(0))
-                .getName());
+                ((PfConceptKey) new JpaAutomationComposition(createAutomationCompositionInstance()).getKeys().get(0))
+                        .getName());
 
         testJpaAutomationComposition.clean();
         assertEquals("automation-composition", testJpaAutomationComposition.getKey().getName());
@@ -167,58 +165,57 @@ class JpaAutomationCompositionTest {
         testJpaAutomationComposition.clean();
         assertEquals("A Message", testJpaAutomationComposition.getDescription());
 
-        JpaAutomationComposition testJpaAutomationComposition2 =
-            new JpaAutomationComposition(testJpaAutomationComposition);
+        var testJpaAutomationComposition2 = new JpaAutomationComposition(testJpaAutomationComposition);
         assertEquals(testJpaAutomationComposition, testJpaAutomationComposition2);
     }
 
     @Test
     void testJpaAutomationCompositionElementOrderedState() throws CoderException {
-        AutomationComposition testAutomationComposition = createAutomationCompositionInstance();
-        JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
+        var testAutomationComposition = createAutomationCompositionInstance();
+        var testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 
         testJpaAutomationComposition.setOrderedState(null);
         assertEquals(testAutomationComposition, testJpaAutomationComposition.toAuthorative());
         testJpaAutomationComposition.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
 
-        AutomationComposition noOrderedStateAc = new StandardCoder().decode(
-            new File("src/test/resources/json/AutomationCompositionNoOrderedState.json"), AutomationComposition.class);
+        var noOrderedStateAc =
+                new StandardCoder().decode(new File("src/test/resources/json/AutomationCompositionNoOrderedState.json"),
+                        AutomationComposition.class);
 
-        JpaAutomationComposition noOrderedStateJpaAc = new JpaAutomationComposition(noOrderedStateAc);
+        var noOrderedStateJpaAc = new JpaAutomationComposition(noOrderedStateAc);
         assertNull(noOrderedStateJpaAc.getOrderedState());
         noOrderedStateAc.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
         noOrderedStateJpaAc = new JpaAutomationComposition(noOrderedStateAc);
         assertEquals(testJpaAutomationComposition, noOrderedStateJpaAc);
 
-        AutomationCompositions automationCompositionsWithElements = new StandardCoder().decode(
-            new File("src/test/resources/providers/TestAutomationCompositions.json"), AutomationCompositions.class);
+        var automationCompositionsWithElements = new StandardCoder().decode(
+                new File("src/test/resources/providers/TestAutomationCompositions.json"), AutomationCompositions.class);
 
-        JpaAutomationComposition jpaAutomationCompositionWithElements =
-            new JpaAutomationComposition(automationCompositionsWithElements.getAutomationCompositionList().get(0));
+        var jpaAutomationCompositionWithElements =
+                new JpaAutomationComposition(automationCompositionsWithElements.getAutomationCompositionList().get(0));
         assertEquals(4, jpaAutomationCompositionWithElements.getElements().size());
-        assertEquals(18, jpaAutomationCompositionWithElements.getKeys().size());
+        assertEquals(17, jpaAutomationCompositionWithElements.getKeys().size());
         assertThatCode(jpaAutomationCompositionWithElements::clean).doesNotThrowAnyException();
 
         assertEquals(automationCompositionsWithElements.getAutomationCompositionList().get(0),
-            jpaAutomationCompositionWithElements.toAuthorative());
+                jpaAutomationCompositionWithElements.toAuthorative());
     }
 
     @Test
     void testJpaAutomationCompositionValidation() {
-        JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
+        var testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 
         assertThatThrownBy(() -> testJpaAutomationComposition.validate(null))
-            .hasMessageMatching("fieldName is marked .*ull but is null");
+                .hasMessageMatching("fieldName is marked .*ull but is null");
 
         assertTrue(testJpaAutomationComposition.validate("").isValid());
     }
 
     @Test
     void testJpaAutomationCompositionCompareTo() {
-        JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
+        var testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 
-        JpaAutomationComposition otherJpaAutomationComposition =
-            new JpaAutomationComposition(testJpaAutomationComposition);
+        var otherJpaAutomationComposition = new JpaAutomationComposition(testJpaAutomationComposition);
         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
         assertEquals(-1, testJpaAutomationComposition.compareTo(null));
         assertEquals(0, testJpaAutomationComposition.compareTo(testJpaAutomationComposition));
@@ -229,9 +226,9 @@ class JpaAutomationCompositionTest {
         testJpaAutomationComposition.setKey(new PfConceptKey("automation-composition", "0.0.1"));
         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 
-        testJpaAutomationComposition.setDefinition(new PfConceptKey("BadValue", "0.0.1"));
+        testJpaAutomationComposition.setCompositionId(UUID.randomUUID().toString());
         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
-        testJpaAutomationComposition.setDefinition(new PfConceptKey("automationCompositionDefinitionName", "0.0.1"));
+        testJpaAutomationComposition.setCompositionId(COMPOSITION_ID);
         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 
         testJpaAutomationComposition.setState(AutomationCompositionState.PASSIVE);
@@ -260,16 +257,17 @@ class JpaAutomationCompositionTest {
     @Test
     void testJpaAutomationCompositionLombok() {
         assertNotNull(new AutomationComposition());
-        JpaAutomationComposition ac0 = new JpaAutomationComposition();
+        var ac0 = new JpaAutomationComposition();
+        ac0.setCompositionId(COMPOSITION_ID);
 
         assertThat(ac0.toString()).contains("JpaAutomationComposition(");
         assertThat(ac0.hashCode()).isNotZero();
         assertEquals(ac0, ac0);
         assertNotEquals(null, ac0);
 
-        JpaAutomationComposition ac1 = new JpaAutomationComposition();
+        var ac1 = new JpaAutomationComposition();
 
-        ac1.setDefinition(new PfConceptKey("defName", "0.0.1"));
+        ac1.setCompositionId(UUID.randomUUID().toString());
         ac1.setDescription("Description");
         ac1.setElements(new LinkedHashMap<>());
         ac1.setKey(new PfConceptKey("participant", "0.0.1"));
@@ -282,13 +280,14 @@ class JpaAutomationCompositionTest {
 
         assertNotEquals(ac1, ac0);
 
-        JpaAutomationComposition ac2 = new JpaAutomationComposition();
+        var ac2 = new JpaAutomationComposition();
+        ac2.setCompositionId(COMPOSITION_ID);
         assertEquals(ac2, ac0);
     }
 
     private JpaAutomationComposition createJpaAutomationCompositionInstance() {
-        AutomationComposition testAutomationComposition = createAutomationCompositionInstance();
-        JpaAutomationComposition testJpaAutomationComposition = new JpaAutomationComposition();
+        var testAutomationComposition = createAutomationCompositionInstance();
+        var testJpaAutomationComposition = new JpaAutomationComposition();
         testJpaAutomationComposition.setKey(null);
         testJpaAutomationComposition.fromAuthorative(testAutomationComposition);
         testJpaAutomationComposition.setKey(PfConceptKey.getNullKey());
@@ -298,11 +297,10 @@ class JpaAutomationCompositionTest {
     }
 
     private AutomationComposition createAutomationCompositionInstance() {
-        AutomationComposition testAutomationComposition = new AutomationComposition();
+        var testAutomationComposition = new AutomationComposition();
         testAutomationComposition.setName("automation-composition");
         testAutomationComposition.setVersion("0.0.1");
-        testAutomationComposition
-            .setDefinition(new ToscaConceptIdentifier("automationCompositionDefinitionName", "0.0.1"));
+        testAutomationComposition.setCompositionId(UUID.fromString(COMPOSITION_ID));
         testAutomationComposition.setElements(new LinkedHashMap<>());
 
         return testAutomationComposition;
diff --git a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/provider/AutomationCompositionProviderTest.java b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/provider/AutomationCompositionProviderTest.java
index e381693ee..5be603d0d 100644
--- a/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/provider/AutomationCompositionProviderTest.java
+++ b/models/src/test/java/org/onap/policy/clamp/models/acm/persistence/provider/AutomationCompositionProviderTest.java
@@ -23,7 +23,6 @@ package org.onap.policy.clamp.models.acm.persistence.provider;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
@@ -38,15 +37,11 @@ import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
-import org.onap.policy.clamp.models.acm.persistence.repository.ToscaNodeTemplateRepository;
 import org.onap.policy.common.utils.coder.Coder;
 import org.onap.policy.common.utils.coder.StandardCoder;
 import org.onap.policy.common.utils.resources.ResourceUtils;
 import org.onap.policy.models.base.PfConceptKey;
 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
-import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate;
 
 class AutomationCompositionProviderTest {
 
@@ -60,7 +55,7 @@ class AutomationCompositionProviderTest {
 
     private static final Coder CODER = new StandardCoder();
     private static final String AUTOMATION_COMPOSITION_JSON =
-        "src/test/resources/providers/TestAutomationCompositions.json";
+            "src/test/resources/providers/TestAutomationCompositions.json";
 
     private AutomationCompositions inputAutomationCompositions;
     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
@@ -70,71 +65,64 @@ class AutomationCompositionProviderTest {
     void beforeSetupDao() throws Exception {
         inputAutomationCompositions = CODER.decode(originalJson, AutomationCompositions.class);
         inputAutomationCompositionsJpa =
-            ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
-                JpaAutomationComposition::new, "automation compositions");
+                ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
+                        JpaAutomationComposition::new, "automation compositions");
     }
 
     @Test
     void testAutomationCompositionsSave() throws Exception {
         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
-        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
-            mock(ToscaNodeTemplateRepository.class));
+        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository);
 
         assertThatThrownBy(() -> automationCompositionProvider.saveAutomationCompositions(null))
-            .hasMessageMatching(LIST_IS_NULL);
+                .hasMessageMatching(LIST_IS_NULL);
 
         when(automationCompositionRepository.saveAll(inputAutomationCompositionsJpa))
-            .thenReturn(inputAutomationCompositionsJpa);
+                .thenReturn(inputAutomationCompositionsJpa);
 
         var createdAutomationCompositions = new AutomationCompositions();
         createdAutomationCompositions.setAutomationCompositionList(automationCompositionProvider
-            .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()));
+                .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()));
 
         assertEquals(inputAutomationCompositions, createdAutomationCompositions);
 
         when(automationCompositionRepository.saveAll(any())).thenThrow(IllegalArgumentException.class);
 
         assertThatThrownBy(() -> automationCompositionProvider
-            .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()))
-            .hasMessageMatching("Error in save AutomationCompositions");
+                .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()))
+                        .hasMessageMatching("Error in save AutomationCompositions");
     }
 
     @Test
     void testAutomationCompositionSave() throws Exception {
         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
-        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
-            mock(ToscaNodeTemplateRepository.class));
+        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository);
 
         assertThatThrownBy(() -> automationCompositionProvider.saveAutomationComposition(null))
-            .hasMessageMatching(OBJECT_IS_NULL);
+                .hasMessageMatching(OBJECT_IS_NULL);
 
         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
-            .thenReturn(inputAutomationCompositionsJpa.get(0));
+                .thenReturn(inputAutomationCompositionsJpa.get(0));
 
         var createdAutomationComposition = automationCompositionProvider
-            .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
+                .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 
         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 
         when(automationCompositionRepository.save(any())).thenThrow(IllegalArgumentException.class);
 
         assertThatThrownBy(() -> automationCompositionProvider
-            .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0)))
-            .hasMessageMatching("Error in save automationComposition");
+                .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0)))
+                        .hasMessageMatching("Error in save automationComposition");
     }
 
     @Test
     void testGetAutomationCompositions() throws Exception {
         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
-        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
-            mock(ToscaNodeTemplateRepository.class));
-
-        // Return empty list when no data present in db
-        List<AutomationComposition> getResponse = automationCompositionProvider.getAutomationCompositions();
-        assertThat(getResponse).isEmpty();
+        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository);
 
         automationCompositionProvider
-            .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
+                .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
 
         var automationComposition0 = inputAutomationCompositions.getAutomationCompositionList().get(1);
         var name = automationComposition0.getName();
@@ -142,22 +130,22 @@ class AutomationCompositionProviderTest {
         var automationComposition1 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 
         when(automationCompositionRepository.getFiltered(eq(JpaAutomationComposition.class), any(), any()))
-            .thenReturn(List.of(new JpaAutomationComposition(automationComposition0),
-                new JpaAutomationComposition(automationComposition1)));
+                .thenReturn(List.of(new JpaAutomationComposition(automationComposition0),
+                        new JpaAutomationComposition(automationComposition1)));
         when(automationCompositionRepository.findById(automationComposition0.getKey().asIdentifier().asConceptKey()))
-            .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition0)));
+                .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition0)));
         when(automationCompositionRepository.getById(automationComposition0.getKey().asIdentifier().asConceptKey()))
-            .thenReturn(new JpaAutomationComposition(automationComposition0));
+                .thenReturn(new JpaAutomationComposition(automationComposition0));
         when(automationCompositionRepository.getFiltered(JpaAutomationComposition.class, name, version))
-            .thenReturn(List.of(new JpaAutomationComposition(automationComposition0)));
+                .thenReturn(List.of(new JpaAutomationComposition(automationComposition0)));
         when(automationCompositionRepository.findById(automationComposition1.getKey().asIdentifier().asConceptKey()))
-            .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition1)));
+                .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition1)));
 
         assertEquals(1, automationCompositionProvider.getAutomationCompositions(name, version).size());
 
         var ac = automationCompositionProvider
-            .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION))
-            .orElse(new AutomationComposition());
+                .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION))
+                .orElse(new AutomationComposition());
         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 
         ac = automationCompositionProvider.getAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION));
@@ -166,79 +154,39 @@ class AutomationCompositionProviderTest {
         when(automationCompositionRepository.getById(any())).thenThrow(EntityNotFoundException.class);
 
         assertThatThrownBy(() -> automationCompositionProvider
-            .getAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION)))
-            .hasMessageMatching("AutomationComposition not found");
+                .getAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION)))
+                        .hasMessageMatching("AutomationComposition not found");
 
         ac = automationCompositionProvider.findAutomationComposition(ID_NAME, ID_VERSION)
-            .orElse(new AutomationComposition());
+                .orElse(new AutomationComposition());
         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 
         assertThat(automationCompositionProvider
-            .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION))).isEmpty();
+                .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION))).isEmpty();
 
         when(automationCompositionRepository.findById(any())).thenThrow(IllegalArgumentException.class);
 
         assertThatThrownBy(() -> automationCompositionProvider.findAutomationComposition(ID_NAME_NOT_VALID, ID_VERSION))
-            .hasMessageMatching("Not valid parameter");
+                .hasMessageMatching("Not valid parameter");
     }
 
     @Test
     void testDeleteAutomationComposition() throws Exception {
         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
-        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
-            mock(ToscaNodeTemplateRepository.class));
+        var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository);
 
-        assertThatThrownBy(() -> automationCompositionProvider
-            .deleteAutomationComposition(ID_NAME_NOT_EXTST, ID_VERSION))
-            .hasMessageMatching(".*.failed, automation composition does not exist");
+        assertThatThrownBy(
+                () -> automationCompositionProvider.deleteAutomationComposition(ID_NAME_NOT_EXTST, ID_VERSION))
+                        .hasMessageMatching(".*.failed, automation composition does not exist");
 
         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
         var name = automationComposition.getName();
         var version = automationComposition.getVersion();
 
         when(automationCompositionRepository.findById(new PfConceptKey(name, version)))
-            .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
+                .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 
         AutomationComposition deletedAc = automationCompositionProvider.deleteAutomationComposition(name, version);
         assertEquals(automationComposition, deletedAc);
     }
-
-    @Test
-    void testGetNodeTemplates() {
-        var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
-        var automationCompositionProvider =
-            new AutomationCompositionProvider(mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository);
-
-        var toscaNodeTemplate0 = new JpaToscaNodeTemplate(new PfConceptKey(ID_NAME, ID_VERSION));
-        var toscaNodeTemplate1 = new JpaToscaNodeTemplate(new PfConceptKey("PMSHInstance2", ID_VERSION));
-
-        when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, null, null))
-            .thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
-        when(toscaNodeTemplateRepository.findAll()).thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
-        when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, ID_NAME, ID_VERSION))
-            .thenReturn(List.of(toscaNodeTemplate0));
-
-        // Getting all nodes
-        var listNodes = automationCompositionProvider.getAllNodeTemplates();
-        assertNotNull(listNodes);
-        assertThat(listNodes).hasSize(2);
-
-        listNodes = automationCompositionProvider.getNodeTemplates(ID_NAME, ID_VERSION);
-        assertNotNull(listNodes);
-        assertThat(listNodes).hasSize(1);
-
-        listNodes = automationCompositionProvider.getAllNodeTemplates();
-        assertNotNull(listNodes);
-        assertThat(listNodes).hasSize(2);
-
-        var nodeTemplateFilter =
-            ToscaTypedEntityFilter.<ToscaNodeTemplate>builder().name(ID_NAME).version(ID_VERSION).build();
-
-        listNodes = automationCompositionProvider.getFilteredNodeTemplates(nodeTemplateFilter);
-        assertNotNull(listNodes);
-        assertThat(listNodes).hasSize(1);
-
-        assertThatThrownBy(() -> automationCompositionProvider.getFilteredNodeTemplates(null))
-            .hasMessageMatching("filter is marked non-null but is null");
-    }
 }