[FEAT] update @ManyToMany Tests

test/src/test/atriasoft/archidata/dataAccess/TestManyToManyLong.java

@@ -1,6 +1,7 @@
 package test.atriasoft.archidata.dataAccess;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.atriasoft.archidata.dataAccess.DBAccessSQL;
@@ -10,8 +11,10 @@ import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
@@ -38,8 +41,12 @@ public class TestManyToManyLong {
 		ConfigureDb.clear();
 	}
 
-	@Order(1)
+	@Nested
-	@Test
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class SimpleTestInsertionAndRetrieve {
+
+		@BeforeAll
 		public void testCreateTable() throws Exception {
 			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
 			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
@@ -52,11 +59,19 @@ public class TestManyToManyLong {
 			}
 		}
 
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyLongRoot.class);
+				daSQL.drop(TypeManyToManyLongRemote.class);
+			}
+		}
+
 		@Order(2)
 		@Test
 		public void testSimpleInsertAndRetieve() throws Exception {
 			final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
-		test.otherData = "kjhlkjlkj";
+			test.otherData = "root insert";
 			final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
 			Assertions.assertNotNull(insertedData);
 			Assertions.assertNotNull(insertedData.id);
@@ -75,103 +90,468 @@ public class TestManyToManyLong {
 
 			ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
 		}
+	}
 
+	// TODO: add and remove link from remote class
 	@Order(3)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class AddLinkInsertInRoot {
+		TypeManyToManyLongRemote insertedRemote1;
+		TypeManyToManyLongRemote insertedRemote2;
+		TypeManyToManyLongRoot insertedData;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyLongRoot.class);
+				daSQL.drop(TypeManyToManyLongRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
 		@Test
-	public void testSimpleInsertAndRetieveSubValues() throws Exception {
+		public void addRemotes() throws Exception {
 
 			TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyLongRemote.class, this.insertedRemote1.id);
+			}
+			remote = new TypeManyToManyLongRemote();
 			remote.data = "remote1";
-		final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote1.data, remote.data);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
 
 			remote = new TypeManyToManyLongRemote();
 			remote.data = "remote2";
-		final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote2.data, remote.data);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+		}
+
+		@Order(2)
+		@Test
+		public void insertDataWithoutRemote() throws Exception {
 
 			final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
-		test.otherData = "kjhlkjlkj";
+			test.otherData = "root insert 55";
-		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
+			this.insertedData = ConfigureDb.da.insert(test);
-		Assertions.assertNotNull(insertedData);
+			Assertions.assertNotNull(this.insertedData);
-		Assertions.assertNotNull(insertedData.id);
+			Assertions.assertNotNull(this.insertedData.id);
-		Assertions.assertTrue(insertedData.id >= 0);
+			Assertions.assertTrue(this.insertedData.id >= 0);
-		Assertions.assertNull(insertedData.remote);
+			Assertions.assertNull(this.insertedData.remote);
 
 			// Try to retrieve all the data:
-		TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedData.id);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.id);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.id, retrieve.id);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
+		}
 
+		@Order(3)
+		@Test
+		public void addLinksRemotes() throws Exception {
 			// Add remote elements
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id, "remote",
-				insertedRemote1.id);
+					this.insertedRemote1.id);
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id, "remote",
-				insertedRemote2.id);
+					this.insertedRemote2.id);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedData.id);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.id);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.id, retrieve.id);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(2, retrieve.remote.size());
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.id);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote1.id);
-		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.id);
+			Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.id);
 
+			// -- Verify remote is linked:
+			final TypeManyToManyLongRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
+					this.insertedRemote1.id);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.id);
+			Assertions.assertEquals(this.insertedRemote1.id, retrieveRemote.id);
+			Assertions.assertNotNull(retrieveRemote.data);
+			Assertions.assertEquals(this.insertedRemote1.data, retrieveRemote.data);
+			Assertions.assertNotNull(retrieveRemote.remoteToParent);
+			Assertions.assertEquals(1, retrieveRemote.remoteToParent.size());
+			Assertions.assertEquals(this.insertedData.id, retrieveRemote.remoteToParent.get(0));
+		}
+
+		@Order(3)
+		@Test
+		public void testExpand() throws Exception {
 			final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
-				insertedData.id);
+					this.insertedData.id);
 
 			Assertions.assertNotNull(retrieveExpand);
 			Assertions.assertNotNull(retrieveExpand.id);
-		Assertions.assertEquals(insertedData.id, retrieveExpand.id);
+			Assertions.assertEquals(this.insertedData.id, retrieveExpand.id);
 			Assertions.assertNotNull(retrieveExpand.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieveExpand.otherData);
 			Assertions.assertNotNull(retrieveExpand.remote);
 			Assertions.assertEquals(2, retrieveExpand.remote.size());
-		Assertions.assertEquals(retrieveExpand.remote.get(0).id, insertedRemote1.id);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).id, this.insertedRemote1.id);
-		Assertions.assertEquals(retrieveExpand.remote.get(1).id, insertedRemote2.id);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).data, this.insertedRemote1.data);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).id, this.insertedRemote2.id);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).data, this.insertedRemote2.data);
+		}
 
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
 			// Remove an element
-		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id,
-				insertedRemote1.id);
+					"remote", this.insertedRemote1.id);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedData.id);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.id);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.id, retrieve.id);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(retrieve.remote.size(), 1);
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote2.id);
 
 			// Remove the second element
 			count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
-				insertedRemote2.id);
+					this.insertedRemote2.id);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedData.id);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.id);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.id, retrieve.id);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
+			ConfigureDb.da.delete(TypeManyToManyLongRoot.class, this.insertedData.id);
+		}
 	}
 
-	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */
+	@Order(4)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class directInsertAndRemoveInRoot {
+		TypeManyToManyLongRemote insertedRemote1;
+		TypeManyToManyLongRemote insertedRemote2;
+		TypeManyToManyLongRoot insertedRoot1;
+		TypeManyToManyLongRoot insertedRoot2;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyLongRoot.class);
+				daSQL.drop(TypeManyToManyLongRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
+		@Test
+		public void addRemotes() throws Exception {
+
+			TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyLongRemote.class, this.insertedRemote1.id);
+			}
+			remote = new TypeManyToManyLongRemote();
+			remote.data = "remote 1";
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
+
+			remote = new TypeManyToManyLongRemote();
+			remote.data = "remote 2";
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+
+			TypeManyToManyLongRoot root = new TypeManyToManyLongRoot();
+			root.otherData = "root 1";
+			this.insertedRoot1 = ConfigureDb.da.insert(root);
+
+			root = new TypeManyToManyLongRoot();
+			root.otherData = "root 2";
+			this.insertedRoot2 = ConfigureDb.da.insert(root);
+		}
+
+		@Order(3)
+		@Test
+		public void addLinksRemotes() throws Exception {
+			// Add remote elements
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRemote.class, this.insertedRemote2.id,
+					"remoteToParent", this.insertedRoot1.id);
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRemote.class, this.insertedRemote2.id,
+					"remoteToParent", this.insertedRoot2.id);
+
+			final TypeManyToManyLongRemote retrieve = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
+					this.insertedRemote2.id);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.id);
+			Assertions.assertEquals(this.insertedRemote2.id, retrieve.id);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(2, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.id, retrieve.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.id, retrieve.remoteToParent.get(1));
+
+			final TypeManyToManyLongRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot1.id);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.id);
+			Assertions.assertEquals(this.insertedRoot1.id, retrieveExpand.id);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.id, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyLongRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot2.id);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.id);
+			Assertions.assertEquals(this.insertedRoot2.id, retrieveRemote.id);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNotNull(retrieveRemote.remote);
+			Assertions.assertEquals(1, retrieveRemote.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.id, retrieveRemote.remote.get(0));
+		}
+
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRemote.class, this.insertedRemote2.id,
+					"remoteToParent", this.insertedRoot2.id);
+
+			final TypeManyToManyLongRemote retrieve = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
+					this.insertedRemote2.id);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.id);
+			Assertions.assertEquals(this.insertedRemote2.id, retrieve.id);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(1, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.id, retrieve.remoteToParent.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyLongRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot1.id);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.id);
+			Assertions.assertEquals(this.insertedRoot1.id, retrieveExpand.id);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.id, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyLongRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot2.id);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.id);
+			Assertions.assertEquals(this.insertedRoot2.id, retrieveRemote.id);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
 
 		}
+
+		@Order(5)
+		@Test
+		public void removeSecondLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRemote.class, this.insertedRemote2.id,
+					"remoteToParent", this.insertedRoot1.id);
+
+			final TypeManyToManyLongRemote retrieve = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
+					this.insertedRemote2.id);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.id);
+			Assertions.assertEquals(this.insertedRemote2.id, retrieve.id);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNull(retrieve.remoteToParent);
+
+			// -- Verify remote is linked:
+			final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
+					this.insertedRoot1.id);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.id);
+			Assertions.assertEquals(this.insertedRoot1.id, retrieveExpand.id);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNull(retrieveExpand.remote);
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyLongRootExpand retrieveRemote = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
+					this.insertedRoot2.id);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.id);
+			Assertions.assertEquals(this.insertedRoot2.id, retrieveRemote.id);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
+
+		}
+
+		TypeManyToManyLongRemote insertedParameters;
+
+		// ---------------------------------------------------------------
+		// -- Add parent with manyToMany in parameters:
+		// ---------------------------------------------------------------
+		@Order(6)
+		@Test
+		public void AddParentWithManyToManyInParameters() throws Exception {
+			final TypeManyToManyLongRemote test = new TypeManyToManyLongRemote();
+			test.data = "insert with remote";
+			test.remoteToParent = new ArrayList<>();
+			test.remoteToParent.add(this.insertedRoot1.id);
+			test.remoteToParent.add(this.insertedRoot2.id);
+			this.insertedParameters = ConfigureDb.da.insert(test);
+			Assertions.assertNotNull(this.insertedParameters);
+			Assertions.assertNotNull(this.insertedParameters.id);
+			Assertions.assertTrue(this.insertedParameters.id >= 0);
+			Assertions.assertNotNull(this.insertedParameters.remoteToParent);
+			Assertions.assertEquals(2, this.insertedParameters.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.id, this.insertedParameters.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.id, this.insertedParameters.remoteToParent.get(1));
+
+			// -- Verify remote is linked:
+			TypeManyToManyLongRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot1.id);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.id);
+			Assertions.assertEquals(this.insertedRoot1.id, retrieveRoot.id);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.id, retrieveRoot.remote.get(0));
+
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedRoot2.id);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.id);
+			Assertions.assertEquals(this.insertedRoot2.id, retrieveRoot.id);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.id, retrieveRoot.remote.get(0));
+
+		}
+
+		// ---------------------------------------------------------------
+		// -- Update Parent Data:
+		// ---------------------------------------------------------------
+		@Order(7)
+		@Test
+		public void updateRequest() throws Exception {
+			final TypeManyToManyLongRemote testUpdate = new TypeManyToManyLongRemote();
+			testUpdate.remoteToParent = new ArrayList<>();
+			testUpdate.remoteToParent.add(this.insertedRoot2.id);
+			final long numberUpdate = ConfigureDb.da.update(testUpdate, this.insertedParameters.id);
+			Assertions.assertEquals(1, numberUpdate);
+
+			final TypeManyToManyLongRemote insertedDataUpdate = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
+					this.insertedParameters.id);
+			Assertions.assertNotNull(insertedDataUpdate);
+			Assertions.assertNotNull(insertedDataUpdate.id);
+			Assertions.assertTrue(insertedDataUpdate.id >= 0);
+			Assertions.assertNotNull(insertedDataUpdate.remoteToParent);
+			Assertions.assertEquals(1, insertedDataUpdate.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot2.id, insertedDataUpdate.remoteToParent.get(0));
+
+			// -- Verify remote is linked (removed):
+			TypeManyToManyLongRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
+					this.insertedRoot1.id);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.id);
+			Assertions.assertEquals(this.insertedRoot1.id, retrieveRoot.id);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNull(retrieveRoot.remote);
+
+			// -- Verify remote is linked (keep):
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedRoot2.id);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.id);
+			Assertions.assertEquals(this.insertedRoot2.id, retrieveRoot.id);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.id, retrieveRoot.remote.get(0));
+
+		}
+	}
+}

test/src/test/atriasoft/archidata/dataAccess/TestManyToManyOID.java

@@ -1,8 +1,7 @@
 package test.atriasoft.archidata.dataAccess;
 
 import java.io.IOException;
-import java.util.Calendar;
+import java.util.ArrayList;
-import java.util.Date;
 import java.util.List;
 
 import org.atriasoft.archidata.dataAccess.DBAccessSQL;
@@ -12,8 +11,10 @@ import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
@@ -40,8 +41,12 @@ public class TestManyToManyOID {
 		ConfigureDb.clear();
 	}
 
-	@Order(1)
+	@Nested
-	@Test
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class SimpleTestInsertionAndRetrieve {
+
+		@BeforeAll
 		public void testCreateTable() throws Exception {
 			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyOIDRoot.class);
 			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyOIDRemote.class);
@@ -54,18 +59,22 @@ public class TestManyToManyOID {
 			}
 		}
 
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyOIDRoot.class);
+				daSQL.drop(TypeManyToManyOIDRemote.class);
+			}
+		}
+
 		@Order(2)
 		@Test
 		public void testSimpleInsertAndRetieve() throws Exception {
-		final Calendar calendar = Calendar.getInstance();
-		calendar.add(Calendar.MINUTE, -1);
-		final Date beginTestDate = calendar.getTime();
 			final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
-		test.otherData = "kjhlkjlkj";
+			test.otherData = "root insert";
 			final TypeManyToManyOIDRoot insertedData = ConfigureDb.da.insert(test);
 			Assertions.assertNotNull(insertedData);
 			Assertions.assertNotNull(insertedData.oid);
-		Assertions.assertTrue(insertedData.oid.getDate().after(beginTestDate));
 			Assertions.assertNull(insertedData.remote);
 
 			// Try to retrieve all the data:
@@ -80,105 +89,465 @@ public class TestManyToManyOID {
 
 			ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
 		}
+	}
 
+	// TODO: add and remove link from remote class
 	@Order(3)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class AddLinkInsertInRoot {
+		TypeManyToManyOIDRemote insertedRemote1;
+		TypeManyToManyOIDRemote insertedRemote2;
+		TypeManyToManyOIDRoot insertedData;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyOIDRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyOIDRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyOIDRoot.class);
+				daSQL.drop(TypeManyToManyOIDRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
 		@Test
-	public void testSimpleInsertAndRetieveSubValues() throws Exception {
+		public void addRemotes() throws Exception {
-		final Calendar calendar = Calendar.getInstance();
+
-		calendar.add(Calendar.MINUTE, -1);
-		final Date beginTestDate = calendar.getTime();
 			TypeManyToManyOIDRemote remote = new TypeManyToManyOIDRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyOIDRemote.class, this.insertedRemote1.oid);
+			}
+			remote = new TypeManyToManyOIDRemote();
 			remote.data = "remote1";
-		final TypeManyToManyOIDRemote insertedRemote1 = ConfigureDb.da.insert(remote);
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote1.data, remote.data);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
 
 			remote = new TypeManyToManyOIDRemote();
 			remote.data = "remote2";
-		final TypeManyToManyOIDRemote insertedRemote2 = ConfigureDb.da.insert(remote);
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote2.data, remote.data);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+		}
+
+		@Order(2)
+		@Test
+		public void insertDataWithoutRemote() throws Exception {
 
 			final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
-		test.otherData = "kjhlkjlkj";
+			test.otherData = "root insert 55";
-		final TypeManyToManyOIDRoot insertedData = ConfigureDb.da.insert(test);
+			this.insertedData = ConfigureDb.da.insert(test);
-		Assertions.assertNotNull(insertedData);
+			Assertions.assertNotNull(this.insertedData);
-		Assertions.assertNotNull(insertedData.oid);
+			Assertions.assertNotNull(this.insertedData.oid);
-		Assertions.assertTrue(insertedData.oid.getDate().after(beginTestDate));
+			Assertions.assertNull(this.insertedData.remote);
-		Assertions.assertNull(insertedData.remote);
 
 			// Try to retrieve all the data:
-		TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+			final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedData.oid);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.oid);
-		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+			Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
+		}
 
+		@Order(3)
+		@Test
+		public void addLinksRemotes() throws Exception {
 			// Add remote elements
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, this.insertedData.oid, "remote",
-				insertedRemote1.oid);
+					this.insertedRemote1.oid);
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, this.insertedData.oid, "remote",
-				insertedRemote2.oid);
+					this.insertedRemote2.oid);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+			final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedData.oid);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.oid);
-		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+			Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(2, retrieve.remote.size());
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.oid);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote1.oid);
-		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.oid);
+			Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.oid);
 
+			// -- Verify remote is linked:
+			final TypeManyToManyOIDRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
+					this.insertedRemote1.oid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.oid);
+			Assertions.assertEquals(this.insertedRemote1.oid, retrieveRemote.oid);
+			Assertions.assertNotNull(retrieveRemote.data);
+			Assertions.assertEquals(this.insertedRemote1.data, retrieveRemote.data);
+			Assertions.assertNotNull(retrieveRemote.remoteToParent);
+			Assertions.assertEquals(1, retrieveRemote.remoteToParent.size());
+			Assertions.assertEquals(this.insertedData.oid, retrieveRemote.remoteToParent.get(0));
+		}
+
+		@Order(3)
+		@Test
+		public void testExpand() throws Exception {
 			final TypeManyToManyOIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
-				insertedData.oid);
+					this.insertedData.oid);
 
 			Assertions.assertNotNull(retrieveExpand);
 			Assertions.assertNotNull(retrieveExpand.oid);
-		Assertions.assertEquals(insertedData.oid, retrieveExpand.oid);
+			Assertions.assertEquals(this.insertedData.oid, retrieveExpand.oid);
 			Assertions.assertNotNull(retrieveExpand.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieveExpand.otherData);
 			Assertions.assertNotNull(retrieveExpand.remote);
 			Assertions.assertEquals(2, retrieveExpand.remote.size());
-		Assertions.assertEquals(retrieveExpand.remote.get(0).oid, insertedRemote1.oid);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).oid, this.insertedRemote1.oid);
-		Assertions.assertEquals(retrieveExpand.remote.get(1).oid, insertedRemote2.oid);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).data, this.insertedRemote1.data);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).oid, this.insertedRemote2.oid);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).data, this.insertedRemote2.data);
+		}
 
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
 			// Remove an element
-		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
+			long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, this.insertedData.oid,
-				insertedRemote1.oid);
+					"remote", this.insertedRemote1.oid);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+			TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedData.oid);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.oid);
-		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+			Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(retrieve.remote.size(), 1);
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.oid);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote2.oid);
 
 			// Remove the second element
 			count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
-				insertedRemote2.oid);
+					this.insertedRemote2.oid);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
+			retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedData.oid);
 
 			Assertions.assertNotNull(retrieve);
 			Assertions.assertNotNull(retrieve.oid);
-		Assertions.assertEquals(insertedData.oid, retrieve.oid);
+			Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
+			ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, this.insertedData.oid);
+		}
 	}
 
-	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */
+	@Order(4)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class directInsertAndRemoveInRoot {
+		TypeManyToManyOIDRemote insertedRemote1;
+		TypeManyToManyOIDRemote insertedRemote2;
+		TypeManyToManyOIDRoot insertedRoot1;
+		TypeManyToManyOIDRoot insertedRoot2;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyOIDRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyOIDRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyOIDRoot.class);
+				daSQL.drop(TypeManyToManyOIDRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
+		@Test
+		public void addRemotes() throws Exception {
+
+			TypeManyToManyOIDRemote remote = new TypeManyToManyOIDRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyOIDRemote.class, this.insertedRemote1.oid);
+			}
+			remote = new TypeManyToManyOIDRemote();
+			remote.data = "remote 1";
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
+
+			remote = new TypeManyToManyOIDRemote();
+			remote.data = "remote 2";
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+
+			TypeManyToManyOIDRoot root = new TypeManyToManyOIDRoot();
+			root.otherData = "root 1";
+			this.insertedRoot1 = ConfigureDb.da.insert(root);
+
+			root = new TypeManyToManyOIDRoot();
+			root.otherData = "root 2";
+			this.insertedRoot2 = ConfigureDb.da.insert(root);
+		}
+
+		@Order(3)
+		@Test
+		public void addLinksRemotes() throws Exception {
+			// Add remote elements
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRemote.class, this.insertedRemote2.oid,
+					"remoteToParent", this.insertedRoot1.oid);
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRemote.class, this.insertedRemote2.oid,
+					"remoteToParent", this.insertedRoot2.oid);
+
+			final TypeManyToManyOIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
+					this.insertedRemote2.oid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.oid);
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieve.oid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(2, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieve.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieve.remoteToParent.get(1));
+
+			final TypeManyToManyOIDRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot1.oid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.oid);
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieveExpand.oid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyOIDRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot2.oid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.oid);
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieveRemote.oid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNotNull(retrieveRemote.remote);
+			Assertions.assertEquals(1, retrieveRemote.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieveRemote.remote.get(0));
+		}
+
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRemote.class, this.insertedRemote2.oid,
+					"remoteToParent", this.insertedRoot2.oid);
+
+			final TypeManyToManyOIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
+					this.insertedRemote2.oid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.oid);
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieve.oid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(1, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieve.remoteToParent.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyOIDRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot1.oid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.oid);
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieveExpand.oid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyOIDRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot2.oid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.oid);
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieveRemote.oid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
 
 		}
+
+		@Order(5)
+		@Test
+		public void removeSecondLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRemote.class, this.insertedRemote2.oid,
+					"remoteToParent", this.insertedRoot1.oid);
+
+			final TypeManyToManyOIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
+					this.insertedRemote2.oid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.oid);
+			Assertions.assertEquals(this.insertedRemote2.oid, retrieve.oid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNull(retrieve.remoteToParent);
+
+			// -- Verify remote is linked:
+			final TypeManyToManyOIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
+					this.insertedRoot1.oid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.oid);
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieveExpand.oid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNull(retrieveExpand.remote);
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyOIDRootExpand retrieveRemote = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
+					this.insertedRoot2.oid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.oid);
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieveRemote.oid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
+
+		}
+
+		TypeManyToManyOIDRemote insertedParameters;
+
+		// ---------------------------------------------------------------
+		// -- Add parent with manyToMany in parameters:
+		// ---------------------------------------------------------------
+		@Order(6)
+		@Test
+		public void AddParentWithManyToManyInParameters() throws Exception {
+			final TypeManyToManyOIDRemote test = new TypeManyToManyOIDRemote();
+			test.data = "insert with remote";
+			test.remoteToParent = new ArrayList<>();
+			test.remoteToParent.add(this.insertedRoot1.oid);
+			test.remoteToParent.add(this.insertedRoot2.oid);
+			this.insertedParameters = ConfigureDb.da.insert(test);
+			Assertions.assertNotNull(this.insertedParameters);
+			Assertions.assertNotNull(this.insertedParameters.oid);
+			Assertions.assertNotNull(this.insertedParameters.remoteToParent);
+			Assertions.assertEquals(2, this.insertedParameters.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.oid, this.insertedParameters.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.oid, this.insertedParameters.remoteToParent.get(1));
+
+			// -- Verify remote is linked:
+			TypeManyToManyOIDRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot1.oid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.oid);
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieveRoot.oid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.oid, retrieveRoot.remote.get(0));
+
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedRoot2.oid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.oid);
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieveRoot.oid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.oid, retrieveRoot.remote.get(0));
+
+		}
+
+		// ---------------------------------------------------------------
+		// -- Update Parent Data:
+		// ---------------------------------------------------------------
+		@Order(7)
+		@Test
+		public void updateRequest() throws Exception {
+			final TypeManyToManyOIDRemote testUpdate = new TypeManyToManyOIDRemote();
+			testUpdate.remoteToParent = new ArrayList<>();
+			testUpdate.remoteToParent.add(this.insertedRoot2.oid);
+			final long numberUpdate = ConfigureDb.da.update(testUpdate, this.insertedParameters.oid);
+			Assertions.assertEquals(1, numberUpdate);
+
+			final TypeManyToManyOIDRemote insertedDataUpdate = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
+					this.insertedParameters.oid);
+			Assertions.assertNotNull(insertedDataUpdate);
+			Assertions.assertNotNull(insertedDataUpdate.oid);
+			Assertions.assertNotNull(insertedDataUpdate.remoteToParent);
+			Assertions.assertEquals(1, insertedDataUpdate.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot2.oid, insertedDataUpdate.remoteToParent.get(0));
+
+			// -- Verify remote is linked (removed):
+			TypeManyToManyOIDRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
+					this.insertedRoot1.oid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.oid);
+			Assertions.assertEquals(this.insertedRoot1.oid, retrieveRoot.oid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNull(retrieveRoot.remote);
+
+			// -- Verify remote is linked (keep):
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedRoot2.oid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.oid);
+			Assertions.assertEquals(this.insertedRoot2.oid, retrieveRoot.oid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.oid, retrieveRoot.remote.get(0));
+
+		}
+	}
+}

test/src/test/atriasoft/archidata/dataAccess/TestManyToManyUUID.java

@@ -1,6 +1,8 @@
+
 package test.atriasoft.archidata.dataAccess;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.atriasoft.archidata.dataAccess.DBAccessSQL;
@@ -10,8 +12,10 @@ import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
@@ -19,14 +23,14 @@ import org.slf4j.LoggerFactory;
 
 import test.atriasoft.archidata.ConfigureDb;
 import test.atriasoft.archidata.StepwiseExtension;
-import test.atriasoft.archidata.dataAccess.model.TypeManyToManyLongRemote;
+import test.atriasoft.archidata.dataAccess.model.TypeManyToManyUUIDRemote;
-import test.atriasoft.archidata.dataAccess.model.TypeManyToManyLongRoot;
+import test.atriasoft.archidata.dataAccess.model.TypeManyToManyUUIDRoot;
-import test.atriasoft.archidata.dataAccess.model.TypeManyToManyLongRootExpand;
+import test.atriasoft.archidata.dataAccess.model.TypeManyToManyUUIDRootExpand;
 
 @ExtendWith(StepwiseExtension.class)
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 public class TestManyToManyUUID {
-	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToManyLong.class);
+	final static private Logger LOGGER = LoggerFactory.getLogger(TestManyToManyUUID.class);
 
 	@BeforeAll
 	public static void configureWebServer() throws Exception {
@@ -38,11 +42,15 @@ public class TestManyToManyUUID {
 		ConfigureDb.clear();
 	}
 
-	@Order(1)
+	@Nested
-	@Test
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class SimpleTestInsertionAndRetrieve {
+
+		@BeforeAll
 		public void testCreateTable() throws Exception {
-		final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyLongRoot.class);
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyUUIDRoot.class);
-		final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyLongRemote.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyUUIDRemote.class);
 			sqlCommand.addAll(sqlCommand2);
 			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
 				for (final String elem : sqlCommand) {
@@ -52,126 +60,495 @@ public class TestManyToManyUUID {
 			}
 		}
 
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyUUIDRoot.class);
+				daSQL.drop(TypeManyToManyUUIDRemote.class);
+			}
+		}
+
 		@Order(2)
 		@Test
 		public void testSimpleInsertAndRetieve() throws Exception {
-		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
+			final TypeManyToManyUUIDRoot test = new TypeManyToManyUUIDRoot();
-		test.otherData = "kjhlkjlkj";
+			test.otherData = "root insert";
-		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
+			final TypeManyToManyUUIDRoot insertedData = ConfigureDb.da.insert(test);
 			Assertions.assertNotNull(insertedData);
-		Assertions.assertNotNull(insertedData.id);
+			Assertions.assertNotNull(insertedData.uuid);
-		Assertions.assertTrue(insertedData.id >= 0);
 			Assertions.assertNull(insertedData.remote);
 
 			// Try to retrieve all the data:
-		final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, insertedData.uuid);
 
 			Assertions.assertNotNull(retrieve);
-		Assertions.assertNotNull(retrieve.id);
+			Assertions.assertNotNull(retrieve.uuid);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(insertedData.uuid, retrieve.uuid);
 			Assertions.assertNotNull(retrieve.otherData);
 			Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
+			ConfigureDb.da.delete(TypeManyToManyUUIDRoot.class, insertedData.uuid);
+		}
+	}
+
+	// TODO: add and remove link from remote class
+	@Order(3)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class AddLinkInsertInRoot {
+		TypeManyToManyUUIDRemote insertedRemote1;
+		TypeManyToManyUUIDRemote insertedRemote2;
+		TypeManyToManyUUIDRoot insertedData;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyUUIDRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyUUIDRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyUUIDRoot.class);
+				daSQL.drop(TypeManyToManyUUIDRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
+		@Test
+		public void addRemotes() throws Exception {
+
+			TypeManyToManyUUIDRemote remote = new TypeManyToManyUUIDRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyUUIDRemote.class, this.insertedRemote1.uuid);
+			}
+			remote = new TypeManyToManyUUIDRemote();
+			remote.data = "remote1";
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
+
+			remote = new TypeManyToManyUUIDRemote();
+			remote.data = "remote2";
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+		}
+
+		@Order(2)
+		@Test
+		public void insertDataWithoutRemote() throws Exception {
+
+			final TypeManyToManyUUIDRoot test = new TypeManyToManyUUIDRoot();
+			test.otherData = "root insert 55";
+			this.insertedData = ConfigureDb.da.insert(test);
+			Assertions.assertNotNull(this.insertedData);
+			Assertions.assertNotNull(this.insertedData.uuid);
+			Assertions.assertNull(this.insertedData.remote);
+
+			// Try to retrieve all the data:
+			final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedData.uuid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.uuid);
+			Assertions.assertEquals(this.insertedData.uuid, retrieve.uuid);
+			Assertions.assertNotNull(retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
+			Assertions.assertNull(retrieve.remote);
 		}
 
 		@Order(3)
 		@Test
-	public void testSimpleInsertAndRetieveSubValues() throws Exception {
+		public void addLinksRemotes() throws Exception {
-
-		TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
-		remote.data = "remote1";
-		final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote1.data, remote.data);
-
-		remote = new TypeManyToManyLongRemote();
-		remote.data = "remote2";
-		final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
-		Assertions.assertEquals(insertedRemote2.data, remote.data);
-
-		final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
-		test.otherData = "kjhlkjlkj";
-		final TypeManyToManyLongRoot insertedData = ConfigureDb.da.insert(test);
-		Assertions.assertNotNull(insertedData);
-		Assertions.assertNotNull(insertedData.id);
-		Assertions.assertTrue(insertedData.id >= 0);
-		Assertions.assertNull(insertedData.remote);
-
-		// Try to retrieve all the data:
-		TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
-
-		Assertions.assertNotNull(retrieve);
-		Assertions.assertNotNull(retrieve.id);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
-		Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
-		Assertions.assertNull(retrieve.remote);
-
 			// Add remote elements
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, this.insertedData.uuid, "remote",
-				insertedRemote1.id);
+					this.insertedRemote1.uuid);
-		AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, this.insertedData.uuid, "remote",
-				insertedRemote2.id);
+					this.insertedRemote2.uuid);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedData.uuid);
 
 			Assertions.assertNotNull(retrieve);
-		Assertions.assertNotNull(retrieve.id);
+			Assertions.assertNotNull(retrieve.uuid);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.uuid, retrieve.uuid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(2, retrieve.remote.size());
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote1.id);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote1.uuid);
-		Assertions.assertEquals(retrieve.remote.get(1), insertedRemote2.id);
+			Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.uuid);
 
-		final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
+			// -- Verify remote is linked:
-				insertedData.id);
+			final TypeManyToManyUUIDRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
+					this.insertedRemote1.uuid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.uuid);
+			Assertions.assertEquals(this.insertedRemote1.uuid, retrieveRemote.uuid);
+			Assertions.assertNotNull(retrieveRemote.data);
+			Assertions.assertEquals(this.insertedRemote1.data, retrieveRemote.data);
+			Assertions.assertNotNull(retrieveRemote.remoteToParent);
+			Assertions.assertEquals(1, retrieveRemote.remoteToParent.size());
+			Assertions.assertEquals(this.insertedData.uuid, retrieveRemote.remoteToParent.get(0));
+		}
+
+		@Order(3)
+		@Test
+		public void testExpand() throws Exception {
+			final TypeManyToManyUUIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyUUIDRootExpand.class,
+					this.insertedData.uuid);
 
 			Assertions.assertNotNull(retrieveExpand);
-		Assertions.assertNotNull(retrieveExpand.id);
+			Assertions.assertNotNull(retrieveExpand.uuid);
-		Assertions.assertEquals(insertedData.id, retrieveExpand.id);
+			Assertions.assertEquals(this.insertedData.uuid, retrieveExpand.uuid);
 			Assertions.assertNotNull(retrieveExpand.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieveExpand.otherData);
 			Assertions.assertNotNull(retrieveExpand.remote);
 			Assertions.assertEquals(2, retrieveExpand.remote.size());
-		Assertions.assertEquals(retrieveExpand.remote.get(0).id, insertedRemote1.id);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).uuid, this.insertedRemote1.uuid);
-		Assertions.assertEquals(retrieveExpand.remote.get(1).id, insertedRemote2.id);
+			Assertions.assertEquals(retrieveExpand.remote.get(0).data, this.insertedRemote1.data);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).uuid, this.insertedRemote2.uuid);
+			Assertions.assertEquals(retrieveExpand.remote.get(1).data, this.insertedRemote2.data);
+		}
 
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
 			// Remove an element
-		long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class,
-				insertedRemote1.id);
+					this.insertedData.uuid, "remote", this.insertedRemote1.uuid);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, this.insertedData.uuid);
 
 			Assertions.assertNotNull(retrieve);
-		Assertions.assertNotNull(retrieve.id);
+			Assertions.assertNotNull(retrieve.uuid);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.uuid, retrieve.uuid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNotNull(retrieve.remote);
 			Assertions.assertEquals(retrieve.remote.size(), 1);
-		Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
+			Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote2.uuid);
 
 			// Remove the second element
-		count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
+			count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, retrieve.uuid, "remote",
-				insertedRemote2.id);
+					this.insertedRemote2.uuid);
 			Assertions.assertEquals(1, count);
 
-		retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
+			retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, this.insertedData.uuid);
 
 			Assertions.assertNotNull(retrieve);
-		Assertions.assertNotNull(retrieve.id);
+			Assertions.assertNotNull(retrieve.uuid);
-		Assertions.assertEquals(insertedData.id, retrieve.id);
+			Assertions.assertEquals(this.insertedData.uuid, retrieve.uuid);
 			Assertions.assertNotNull(retrieve.otherData);
-		Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
+			Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
 			Assertions.assertNull(retrieve.remote);
 
-		ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
+			ConfigureDb.da.delete(TypeManyToManyUUIDRoot.class, this.insertedData.uuid);
+		}
 	}
 
-	/* API TODO: - Replace list (permet de les ordonnées) - remove all links - delete en cascade .... (compliqué...) */
+	@Order(4)
+	@Nested
+	@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+	@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+	class directInsertAndRemoveInRoot {
+		TypeManyToManyUUIDRemote insertedRemote1;
+		TypeManyToManyUUIDRemote insertedRemote2;
+		TypeManyToManyUUIDRoot insertedRoot1;
+		TypeManyToManyUUIDRoot insertedRoot2;
+
+		@BeforeAll
+		public void testCreateTable() throws Exception {
+			final List<String> sqlCommand2 = DataFactory.createTable(TypeManyToManyUUIDRoot.class);
+			final List<String> sqlCommand = DataFactory.createTable(TypeManyToManyUUIDRemote.class);
+			sqlCommand.addAll(sqlCommand2);
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				for (final String elem : sqlCommand) {
+					LOGGER.debug("request: '{}'", elem);
+					daSQL.executeSimpleQuery(elem);
+				}
+			}
+		}
+
+		@AfterAll
+		public void dropTables() throws Exception {
+			if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
+				daSQL.drop(TypeManyToManyUUIDRoot.class);
+				daSQL.drop(TypeManyToManyUUIDRemote.class);
+			}
+		}
+
+		// ---------------------------------------------------------------
+		// -- Add remote:
+		// ---------------------------------------------------------------
+		@Order(1)
+		@Test
+		public void addRemotes() throws Exception {
+
+			TypeManyToManyUUIDRemote remote = new TypeManyToManyUUIDRemote();
+			for (int iii = 0; iii < 100; iii++) {
+				remote.data = "tmp" + iii;
+				this.insertedRemote1 = ConfigureDb.da.insert(remote);
+				ConfigureDb.da.delete(TypeManyToManyUUIDRemote.class, this.insertedRemote1.uuid);
+			}
+			remote = new TypeManyToManyUUIDRemote();
+			remote.data = "remote 1";
+			this.insertedRemote1 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote1.data, remote.data);
+
+			remote = new TypeManyToManyUUIDRemote();
+			remote.data = "remote 2";
+			this.insertedRemote2 = ConfigureDb.da.insert(remote);
+			Assertions.assertEquals(this.insertedRemote2.data, remote.data);
+
+			TypeManyToManyUUIDRoot root = new TypeManyToManyUUIDRoot();
+			root.otherData = "root 1";
+			this.insertedRoot1 = ConfigureDb.da.insert(root);
+
+			root = new TypeManyToManyUUIDRoot();
+			root.otherData = "root 2";
+			this.insertedRoot2 = ConfigureDb.da.insert(root);
+		}
+
+		@Order(3)
+		@Test
+		public void addLinksRemotes() throws Exception {
+			// Add remote elements
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRemote.class, this.insertedRemote2.uuid,
+					"remoteToParent", this.insertedRoot1.uuid);
+			AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRemote.class, this.insertedRemote2.uuid,
+					"remoteToParent", this.insertedRoot2.uuid);
+
+			final TypeManyToManyUUIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
+					this.insertedRemote2.uuid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.uuid);
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieve.uuid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(2, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieve.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieve.remoteToParent.get(1));
+
+			final TypeManyToManyUUIDRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot1.uuid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.uuid);
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieveExpand.uuid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyUUIDRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot2.uuid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.uuid);
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieveRemote.uuid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNotNull(retrieveRemote.remote);
+			Assertions.assertEquals(1, retrieveRemote.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieveRemote.remote.get(0));
+		}
+
+		@Order(4)
+		@Test
+		public void removeLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRemote.class, this.insertedRemote2.uuid,
+					"remoteToParent", this.insertedRoot2.uuid);
+
+			final TypeManyToManyUUIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
+					this.insertedRemote2.uuid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.uuid);
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieve.uuid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNotNull(retrieve.remoteToParent);
+			Assertions.assertEquals(1, retrieve.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieve.remoteToParent.get(0));
+
+			// -- Verify remote is linked:
+			final TypeManyToManyUUIDRoot retrieveExpand = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot1.uuid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.uuid);
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieveExpand.uuid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNotNull(retrieveExpand.remote);
+			Assertions.assertEquals(1, retrieveExpand.remote.size());
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieveExpand.remote.get(0));
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyUUIDRoot retrieveRemote = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot2.uuid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.uuid);
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieveRemote.uuid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
 
 		}
+
+		@Order(5)
+		@Test
+		public void removeSecondLinksRemotes() throws Exception {
+			// Remove root elements
+			AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRemote.class, this.insertedRemote2.uuid,
+					"remoteToParent", this.insertedRoot1.uuid);
+
+			final TypeManyToManyUUIDRemote retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
+					this.insertedRemote2.uuid);
+
+			Assertions.assertNotNull(retrieve);
+			Assertions.assertNotNull(retrieve.uuid);
+			Assertions.assertEquals(this.insertedRemote2.uuid, retrieve.uuid);
+			Assertions.assertNotNull(retrieve.data);
+			Assertions.assertEquals(this.insertedRemote2.data, retrieve.data);
+			Assertions.assertNull(retrieve.remoteToParent);
+
+			// -- Verify remote is linked:
+			final TypeManyToManyUUIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyUUIDRootExpand.class,
+					this.insertedRoot1.uuid);
+
+			Assertions.assertNotNull(retrieveExpand);
+			Assertions.assertNotNull(retrieveExpand.uuid);
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieveExpand.uuid);
+			Assertions.assertNotNull(retrieveExpand.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveExpand.otherData);
+			Assertions.assertNull(retrieveExpand.remote);
+
+			// -- Verify remote is un-linked:
+			final TypeManyToManyUUIDRootExpand retrieveRemote = ConfigureDb.da.get(TypeManyToManyUUIDRootExpand.class,
+					this.insertedRoot2.uuid);
+
+			Assertions.assertNotNull(retrieveRemote);
+			Assertions.assertNotNull(retrieveRemote.uuid);
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieveRemote.uuid);
+			Assertions.assertNotNull(retrieveRemote.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRemote.otherData);
+			Assertions.assertNull(retrieveRemote.remote);
+
+		}
+
+		TypeManyToManyUUIDRemote insertedParameters;
+
+		// ---------------------------------------------------------------
+		// -- Add parent with manyToMany in parameters:
+		// ---------------------------------------------------------------
+		@Order(6)
+		@Test
+		public void AddParentWithManyToManyInParameters() throws Exception {
+			final TypeManyToManyUUIDRemote test = new TypeManyToManyUUIDRemote();
+			test.data = "insert with remote";
+			test.remoteToParent = new ArrayList<>();
+			test.remoteToParent.add(this.insertedRoot1.uuid);
+			test.remoteToParent.add(this.insertedRoot2.uuid);
+			this.insertedParameters = ConfigureDb.da.insert(test);
+			Assertions.assertNotNull(this.insertedParameters);
+			Assertions.assertNotNull(this.insertedParameters.uuid);
+			Assertions.assertNotNull(this.insertedParameters.remoteToParent);
+			Assertions.assertEquals(2, this.insertedParameters.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot1.uuid, this.insertedParameters.remoteToParent.get(0));
+			Assertions.assertEquals(this.insertedRoot2.uuid, this.insertedParameters.remoteToParent.get(1));
+
+			// -- Verify remote is linked:
+			TypeManyToManyUUIDRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot1.uuid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.uuid);
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieveRoot.uuid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.uuid, retrieveRoot.remote.get(0));
+
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, this.insertedRoot2.uuid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.uuid);
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieveRoot.uuid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.uuid, retrieveRoot.remote.get(0));
+
+		}
+
+		// ---------------------------------------------------------------
+		// -- Update Parent Data:
+		// ---------------------------------------------------------------
+		@Order(7)
+		@Test
+		public void updateRequest() throws Exception {
+			final TypeManyToManyUUIDRemote testUpdate = new TypeManyToManyUUIDRemote();
+			testUpdate.remoteToParent = new ArrayList<>();
+			testUpdate.remoteToParent.add(this.insertedRoot2.uuid);
+			final long numberUpdate = ConfigureDb.da.update(testUpdate, this.insertedParameters.uuid);
+			Assertions.assertEquals(1, numberUpdate);
+
+			final TypeManyToManyUUIDRemote insertedDataUpdate = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
+					this.insertedParameters.uuid);
+			Assertions.assertNotNull(insertedDataUpdate);
+			Assertions.assertNotNull(insertedDataUpdate.uuid);
+			Assertions.assertNotNull(insertedDataUpdate.remoteToParent);
+			Assertions.assertEquals(1, insertedDataUpdate.remoteToParent.size());
+			Assertions.assertEquals(this.insertedRoot2.uuid, insertedDataUpdate.remoteToParent.get(0));
+
+			// -- Verify remote is linked (removed):
+			TypeManyToManyUUIDRoot retrieveRoot = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
+					this.insertedRoot1.uuid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.uuid);
+			Assertions.assertEquals(this.insertedRoot1.uuid, retrieveRoot.uuid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot1.otherData, retrieveRoot.otherData);
+			Assertions.assertNull(retrieveRoot.remote);
+
+			// -- Verify remote is linked (keep):
+			retrieveRoot = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, this.insertedRoot2.uuid);
+
+			Assertions.assertNotNull(retrieveRoot);
+			Assertions.assertNotNull(retrieveRoot.uuid);
+			Assertions.assertEquals(this.insertedRoot2.uuid, retrieveRoot.uuid);
+			Assertions.assertNotNull(retrieveRoot.otherData);
+			Assertions.assertEquals(this.insertedRoot2.otherData, retrieveRoot.otherData);
+			Assertions.assertNotNull(retrieveRoot.remote);
+			Assertions.assertEquals(1, retrieveRoot.remote.size());
+			Assertions.assertEquals(this.insertedParameters.uuid, retrieveRoot.remote.get(0));
+
+		}
+	}
+}

test/src/test/atriasoft/archidata/dataAccess/model/TypeManyToManyUUIDRemote.java

@@ -0,0 +1,18 @@
+package test.atriasoft.archidata.dataAccess.model;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.atriasoft.archidata.model.UUIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+
+@Entity
+public class TypeManyToManyUUIDRemote extends UUIDGenericData {
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyUUIDRoot.class, mappedBy = "remote")
+	public List<UUID> remoteToParent;
+	public String data;
+
+}

test/src/test/atriasoft/archidata/dataAccess/model/TypeManyToManyUUIDRoot.java

@@ -0,0 +1,19 @@
+package test.atriasoft.archidata.dataAccess.model;
+
+import java.util.List;
+import java.util.UUID;
+
+import org.atriasoft.archidata.model.UUIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+
+@Entity
+public class TypeManyToManyUUIDRoot extends UUIDGenericData {
+
+	public String otherData;
+
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyUUIDRemote.class, mappedBy = "remoteToParent")
+	public List<UUID> remote;
+}

test/src/test/atriasoft/archidata/dataAccess/model/TypeManyToManyUUIDRootExpand.java

@@ -0,0 +1,21 @@
+package test.atriasoft.archidata.dataAccess.model;
+
+import java.util.List;
+
+import org.atriasoft.archidata.model.UUIDGenericData;
+
+import dev.morphia.annotations.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToMany;
+import jakarta.persistence.Table;
+
+@Table(name = "TypeManyToManyUUIDRoot")
+// for Mongo
+@Entity(value = "TypeManyToManyUUIDRoot")
+public class TypeManyToManyUUIDRootExpand extends UUIDGenericData {
+
+	public String otherData;
+
+	@ManyToMany(fetch = FetchType.LAZY, targetEntity = TypeManyToManyUUIDRemote.class, mappedBy = "remoteToParent")
+	public List<TypeManyToManyUUIDRemote> remote;
+}