[FEAT] update @ManyToMany Tests
This commit is contained in:
parent
7a7ca29081
commit
32d7be23e9
@ -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,140 +41,517 @@ public class TestManyToManyLong {
|
||||
ConfigureDb.clear();
|
||||
}
|
||||
|
||||
@Order(1)
|
||||
@Test
|
||||
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);
|
||||
@Nested
|
||||
@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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@Order(2)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieve() throws Exception {
|
||||
final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
|
||||
test.otherData = "root insert";
|
||||
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:
|
||||
final 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);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
}
|
||||
}
|
||||
|
||||
@Order(2)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieve() throws Exception {
|
||||
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:
|
||||
final 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);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
}
|
||||
|
||||
// TODO: add and remove link from remote class
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieveSubValues() throws Exception {
|
||||
@Nested
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
|
||||
class AddLinkInsertInRoot {
|
||||
TypeManyToManyLongRemote insertedRemote1;
|
||||
TypeManyToManyLongRemote insertedRemote2;
|
||||
TypeManyToManyLongRoot insertedData;
|
||||
|
||||
TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
|
||||
remote.data = "remote1";
|
||||
final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote1.data, remote.data);
|
||||
@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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
remote = new TypeManyToManyLongRemote();
|
||||
remote.data = "remote2";
|
||||
final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote2.data, remote.data);
|
||||
@AfterAll
|
||||
public void dropTables() throws Exception {
|
||||
if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
|
||||
daSQL.drop(TypeManyToManyLongRoot.class);
|
||||
daSQL.drop(TypeManyToManyLongRemote.class);
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
// ---------------------------------------------------------------
|
||||
// -- Add remote:
|
||||
// ---------------------------------------------------------------
|
||||
@Order(1)
|
||||
@Test
|
||||
public void addRemotes() throws Exception {
|
||||
|
||||
// Try to retrieve all the data:
|
||||
TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
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";
|
||||
this.insertedRemote1 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(this.insertedRemote1.data, remote.data);
|
||||
|
||||
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);
|
||||
remote = new TypeManyToManyLongRemote();
|
||||
remote.data = "remote2";
|
||||
this.insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(this.insertedRemote2.data, remote.data);
|
||||
}
|
||||
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote1.id);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote2.id);
|
||||
@Order(2)
|
||||
@Test
|
||||
public void insertDataWithoutRemote() throws Exception {
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
final TypeManyToManyLongRoot test = new TypeManyToManyLongRoot();
|
||||
test.otherData = "root insert 55";
|
||||
this.insertedData = ConfigureDb.da.insert(test);
|
||||
Assertions.assertNotNull(this.insertedData);
|
||||
Assertions.assertNotNull(this.insertedData.id);
|
||||
Assertions.assertTrue(this.insertedData.id >= 0);
|
||||
Assertions.assertNull(this.insertedData.remote);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(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(1), insertedRemote2.id);
|
||||
// Try to retrieve all the data:
|
||||
final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
|
||||
this.insertedData.id);
|
||||
|
||||
final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
|
||||
insertedData.id);
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(this.insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
}
|
||||
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.id);
|
||||
Assertions.assertEquals(insertedData.id, retrieveExpand.id);
|
||||
Assertions.assertNotNull(retrieveExpand.otherData);
|
||||
Assertions.assertEquals(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(1).id, insertedRemote2.id);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void addLinksRemotes() throws Exception {
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id, "remote",
|
||||
this.insertedRemote1.id);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id, "remote",
|
||||
this.insertedRemote2.id);
|
||||
|
||||
// Remove an element
|
||||
long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote1.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
final TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class,
|
||||
this.insertedData.id);
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(this.insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(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), this.insertedRemote1.id);
|
||||
Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.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.assertNotNull(retrieve.remote);
|
||||
Assertions.assertEquals(retrieve.remote.size(), 1);
|
||||
Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
|
||||
// -- Verify remote is linked:
|
||||
final TypeManyToManyLongRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyLongRemote.class,
|
||||
this.insertedRemote1.id);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote2.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
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));
|
||||
}
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testExpand() throws Exception {
|
||||
final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
|
||||
this.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);
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.id);
|
||||
Assertions.assertEquals(this.insertedData.id, retrieveExpand.id);
|
||||
Assertions.assertNotNull(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, this.insertedRemote1.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);
|
||||
}
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
@Order(4)
|
||||
@Test
|
||||
public void removeLinksRemotes() throws Exception {
|
||||
// Remove an element
|
||||
long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, this.insertedData.id,
|
||||
"remote", this.insertedRemote1.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedData.id);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(this.insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(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), this.insertedRemote2.id);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
this.insertedRemote2.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, this.insertedData.id);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(this.insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
|
||||
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));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
package test.atriasoft.archidata.dataAccess;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.ArrayList;
|
||||
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,145 +41,513 @@ public class TestManyToManyOID {
|
||||
ConfigureDb.clear();
|
||||
}
|
||||
|
||||
@Order(1)
|
||||
@Test
|
||||
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);
|
||||
@Nested
|
||||
@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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@Order(2)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieve() throws Exception {
|
||||
final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
|
||||
test.otherData = "root insert";
|
||||
final TypeManyToManyOIDRoot insertedData = ConfigureDb.da.insert(test);
|
||||
Assertions.assertNotNull(insertedData);
|
||||
Assertions.assertNotNull(insertedData.oid);
|
||||
Assertions.assertNull(insertedData.remote);
|
||||
|
||||
// Try to retrieve all the data:
|
||||
final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
}
|
||||
}
|
||||
|
||||
@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";
|
||||
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:
|
||||
final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
}
|
||||
|
||||
// TODO: add and remove link from remote class
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieveSubValues() throws Exception {
|
||||
final Calendar calendar = Calendar.getInstance();
|
||||
calendar.add(Calendar.MINUTE, -1);
|
||||
final Date beginTestDate = calendar.getTime();
|
||||
TypeManyToManyOIDRemote remote = new TypeManyToManyOIDRemote();
|
||||
remote.data = "remote1";
|
||||
final TypeManyToManyOIDRemote insertedRemote1 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote1.data, remote.data);
|
||||
@Nested
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
|
||||
class AddLinkInsertInRoot {
|
||||
TypeManyToManyOIDRemote insertedRemote1;
|
||||
TypeManyToManyOIDRemote insertedRemote2;
|
||||
TypeManyToManyOIDRoot insertedData;
|
||||
|
||||
remote = new TypeManyToManyOIDRemote();
|
||||
remote.data = "remote2";
|
||||
final TypeManyToManyOIDRemote insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote2.data, remote.data);
|
||||
@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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
|
||||
test.otherData = "kjhlkjlkj";
|
||||
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);
|
||||
@AfterAll
|
||||
public void dropTables() throws Exception {
|
||||
if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
|
||||
daSQL.drop(TypeManyToManyOIDRoot.class);
|
||||
daSQL.drop(TypeManyToManyOIDRemote.class);
|
||||
}
|
||||
}
|
||||
|
||||
// Try to retrieve all the data:
|
||||
TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
// ---------------------------------------------------------------
|
||||
// -- Add remote:
|
||||
// ---------------------------------------------------------------
|
||||
@Order(1)
|
||||
@Test
|
||||
public void addRemotes() throws Exception {
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
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";
|
||||
this.insertedRemote1 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(this.insertedRemote1.data, remote.data);
|
||||
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
|
||||
insertedRemote1.oid);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
|
||||
insertedRemote2.oid);
|
||||
remote = new TypeManyToManyOIDRemote();
|
||||
remote.data = "remote2";
|
||||
this.insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(this.insertedRemote2.data, remote.data);
|
||||
}
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
@Order(2)
|
||||
@Test
|
||||
public void insertDataWithoutRemote() throws Exception {
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(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(1), insertedRemote2.oid);
|
||||
final TypeManyToManyOIDRoot test = new TypeManyToManyOIDRoot();
|
||||
test.otherData = "root insert 55";
|
||||
this.insertedData = ConfigureDb.da.insert(test);
|
||||
Assertions.assertNotNull(this.insertedData);
|
||||
Assertions.assertNotNull(this.insertedData.oid);
|
||||
Assertions.assertNull(this.insertedData.remote);
|
||||
|
||||
final TypeManyToManyOIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
|
||||
insertedData.oid);
|
||||
// Try to retrieve all the data:
|
||||
final TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class,
|
||||
this.insertedData.oid);
|
||||
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieveExpand.oid);
|
||||
Assertions.assertNotNull(retrieveExpand.otherData);
|
||||
Assertions.assertEquals(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(1).oid, insertedRemote2.oid);
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
}
|
||||
|
||||
// Remove an element
|
||||
long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
|
||||
insertedRemote1.oid);
|
||||
Assertions.assertEquals(1, count);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void addLinksRemotes() throws Exception {
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, this.insertedData.oid, "remote",
|
||||
this.insertedRemote1.oid);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, this.insertedData.oid, "remote",
|
||||
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.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNotNull(retrieve.remote);
|
||||
Assertions.assertEquals(retrieve.remote.size(), 1);
|
||||
Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.oid);
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(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), this.insertedRemote1.oid);
|
||||
Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.oid);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
|
||||
insertedRemote2.oid);
|
||||
Assertions.assertEquals(1, count);
|
||||
// -- Verify remote is linked:
|
||||
final TypeManyToManyOIDRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyOIDRemote.class,
|
||||
this.insertedRemote1.oid);
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, insertedData.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));
|
||||
}
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testExpand() throws Exception {
|
||||
final TypeManyToManyOIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyOIDRootExpand.class,
|
||||
this.insertedData.oid);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyOIDRoot.class, insertedData.oid);
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.oid);
|
||||
Assertions.assertEquals(this.insertedData.oid, retrieveExpand.oid);
|
||||
Assertions.assertNotNull(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, this.insertedRemote1.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, this.insertedData.oid,
|
||||
"remote", this.insertedRemote1.oid);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
TypeManyToManyOIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedData.oid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(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), this.insertedRemote2.oid);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyOIDRoot.class, retrieve.oid, "remote",
|
||||
this.insertedRemote2.oid);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyOIDRoot.class, this.insertedData.oid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.oid);
|
||||
Assertions.assertEquals(this.insertedData.oid, retrieve.oid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(this.insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
|
||||
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));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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.TypeManyToManyLongRoot;
|
||||
import test.atriasoft.archidata.dataAccess.model.TypeManyToManyLongRootExpand;
|
||||
import test.atriasoft.archidata.dataAccess.model.TypeManyToManyUUIDRemote;
|
||||
import test.atriasoft.archidata.dataAccess.model.TypeManyToManyUUIDRoot;
|
||||
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,140 +42,513 @@ public class TestManyToManyUUID {
|
||||
ConfigureDb.clear();
|
||||
}
|
||||
|
||||
@Order(1)
|
||||
@Test
|
||||
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);
|
||||
@Nested
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
|
||||
class SimpleTestInsertionAndRetrieve {
|
||||
|
||||
@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);
|
||||
}
|
||||
}
|
||||
|
||||
@Order(2)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieve() throws Exception {
|
||||
final TypeManyToManyUUIDRoot test = new TypeManyToManyUUIDRoot();
|
||||
test.otherData = "root insert";
|
||||
final TypeManyToManyUUIDRoot insertedData = ConfigureDb.da.insert(test);
|
||||
Assertions.assertNotNull(insertedData);
|
||||
Assertions.assertNotNull(insertedData.uuid);
|
||||
Assertions.assertNull(insertedData.remote);
|
||||
|
||||
// Try to retrieve all the data:
|
||||
final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class, insertedData.uuid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.uuid);
|
||||
Assertions.assertEquals(insertedData.uuid, retrieve.uuid);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNull(retrieve.remote);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyUUIDRoot.class, insertedData.uuid);
|
||||
}
|
||||
}
|
||||
|
||||
@Order(2)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieve() throws Exception {
|
||||
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:
|
||||
final 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);
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
}
|
||||
|
||||
// TODO: add and remove link from remote class
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testSimpleInsertAndRetieveSubValues() throws Exception {
|
||||
@Nested
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
|
||||
class AddLinkInsertInRoot {
|
||||
TypeManyToManyUUIDRemote insertedRemote1;
|
||||
TypeManyToManyUUIDRemote insertedRemote2;
|
||||
TypeManyToManyUUIDRoot insertedData;
|
||||
|
||||
TypeManyToManyLongRemote remote = new TypeManyToManyLongRemote();
|
||||
remote.data = "remote1";
|
||||
final TypeManyToManyLongRemote insertedRemote1 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote1.data, remote.data);
|
||||
@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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
remote = new TypeManyToManyLongRemote();
|
||||
remote.data = "remote2";
|
||||
final TypeManyToManyLongRemote insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(insertedRemote2.data, remote.data);
|
||||
@AfterAll
|
||||
public void dropTables() throws Exception {
|
||||
if (ConfigureDb.da instanceof final DBAccessSQL daSQL) {
|
||||
daSQL.drop(TypeManyToManyUUIDRoot.class);
|
||||
daSQL.drop(TypeManyToManyUUIDRemote.class);
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
// ---------------------------------------------------------------
|
||||
// -- Add remote:
|
||||
// ---------------------------------------------------------------
|
||||
@Order(1)
|
||||
@Test
|
||||
public void addRemotes() throws Exception {
|
||||
|
||||
// Try to retrieve all the data:
|
||||
TypeManyToManyLongRoot retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
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);
|
||||
|
||||
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);
|
||||
remote = new TypeManyToManyUUIDRemote();
|
||||
remote.data = "remote2";
|
||||
this.insertedRemote2 = ConfigureDb.da.insert(remote);
|
||||
Assertions.assertEquals(this.insertedRemote2.data, remote.data);
|
||||
}
|
||||
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote1.id);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote2.id);
|
||||
@Order(2)
|
||||
@Test
|
||||
public void insertDataWithoutRemote() throws Exception {
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
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);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(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(1), insertedRemote2.id);
|
||||
// Try to retrieve all the data:
|
||||
final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
|
||||
this.insertedData.uuid);
|
||||
|
||||
final TypeManyToManyLongRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyLongRootExpand.class,
|
||||
insertedData.id);
|
||||
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);
|
||||
}
|
||||
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.id);
|
||||
Assertions.assertEquals(insertedData.id, retrieveExpand.id);
|
||||
Assertions.assertNotNull(retrieveExpand.otherData);
|
||||
Assertions.assertEquals(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(1).id, insertedRemote2.id);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void addLinksRemotes() throws Exception {
|
||||
// Add remote elements
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, this.insertedData.uuid, "remote",
|
||||
this.insertedRemote1.uuid);
|
||||
AddOnManyToMany.addLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, this.insertedData.uuid, "remote",
|
||||
this.insertedRemote2.uuid);
|
||||
|
||||
// Remove an element
|
||||
long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote1.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
final TypeManyToManyUUIDRoot retrieve = ConfigureDb.da.get(TypeManyToManyUUIDRoot.class,
|
||||
this.insertedData.uuid);
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
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.assertNotNull(retrieve.remote);
|
||||
Assertions.assertEquals(2, retrieve.remote.size());
|
||||
Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote1.uuid);
|
||||
Assertions.assertEquals(retrieve.remote.get(1), this.insertedRemote2.uuid);
|
||||
|
||||
Assertions.assertNotNull(retrieve);
|
||||
Assertions.assertNotNull(retrieve.id);
|
||||
Assertions.assertEquals(insertedData.id, retrieve.id);
|
||||
Assertions.assertNotNull(retrieve.otherData);
|
||||
Assertions.assertEquals(insertedData.otherData, retrieve.otherData);
|
||||
Assertions.assertNotNull(retrieve.remote);
|
||||
Assertions.assertEquals(retrieve.remote.size(), 1);
|
||||
Assertions.assertEquals(retrieve.remote.get(0), insertedRemote2.id);
|
||||
// -- Verify remote is linked:
|
||||
final TypeManyToManyUUIDRemote retrieveRemote = ConfigureDb.da.get(TypeManyToManyUUIDRemote.class,
|
||||
this.insertedRemote1.uuid);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyLongRoot.class, retrieve.id, "remote",
|
||||
insertedRemote2.id);
|
||||
Assertions.assertEquals(1, count);
|
||||
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));
|
||||
}
|
||||
|
||||
retrieve = ConfigureDb.da.get(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
@Order(3)
|
||||
@Test
|
||||
public void testExpand() throws Exception {
|
||||
final TypeManyToManyUUIDRootExpand retrieveExpand = ConfigureDb.da.get(TypeManyToManyUUIDRootExpand.class,
|
||||
this.insertedData.uuid);
|
||||
|
||||
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);
|
||||
Assertions.assertNotNull(retrieveExpand);
|
||||
Assertions.assertNotNull(retrieveExpand.uuid);
|
||||
Assertions.assertEquals(this.insertedData.uuid, retrieveExpand.uuid);
|
||||
Assertions.assertNotNull(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).uuid, this.insertedRemote1.uuid);
|
||||
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);
|
||||
}
|
||||
|
||||
ConfigureDb.da.delete(TypeManyToManyLongRoot.class, insertedData.id);
|
||||
@Order(4)
|
||||
@Test
|
||||
public void removeLinksRemotes() throws Exception {
|
||||
// Remove an element
|
||||
long count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class,
|
||||
this.insertedData.uuid, "remote", this.insertedRemote1.uuid);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
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.assertNotNull(retrieve.remote);
|
||||
Assertions.assertEquals(retrieve.remote.size(), 1);
|
||||
Assertions.assertEquals(retrieve.remote.get(0), this.insertedRemote2.uuid);
|
||||
|
||||
// Remove the second element
|
||||
count = AddOnManyToMany.removeLink(ConfigureDb.da, TypeManyToManyUUIDRoot.class, retrieve.uuid, "remote",
|
||||
this.insertedRemote2.uuid);
|
||||
Assertions.assertEquals(1, count);
|
||||
|
||||
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);
|
||||
|
||||
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));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user