Refactor move tests from ebean-core to ebean-test

This commit is contained in:
rbygrave committed 2021-09-08 22:49:23 +12:00
1 parent 0b00a14fd3
commit eab56d323b
1650 files changed
+185 -147

No files matched your search

@@ -0,0 +1,40 @@
package org.tests.cascade;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;
import static javax.persistence.CascadeType.ALL;
@Entity
public class COOne {
@Id
private long id;
private final String name;
@OneToMany(cascade = ALL, orphanRemoval = true)
private List<COOneMany> children;
public COOne(String name) {
this.name = name;
}
public long getId() {
return id;
}
public String getName() {
return name;
}
public List<COOneMany> getChildren() {
return children;
}
public void setChildren(List<COOneMany> children) {
this.children = children;
}
}
@@ -0,0 +1,34 @@
package org.tests.cascade;
import io.ebean.annotation.SoftDelete;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class COOneMany {
@Id
private long id;
@SoftDelete
private boolean deleted;
private String name;
public COOneMany(String name) {
this.name = name;
}
public String getName() {
return name;
}
public long getId() {
return id;
}
public boolean isDeleted() {
return deleted;
}
}
@@ -0,0 +1,36 @@
package org.tests.cascade;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import static javax.persistence.CascadeType.ALL;
@Entity
public class CORoot {
@Id
private long id;
private final String name;
@OneToOne(cascade = ALL, orphanRemoval = true)
private COOne one;
public CORoot(String name, COOne one) {
this.name = name;
this.one = one;
}
public long getId() {
return id;
}
public String getName() {
return name;
}
public COOne getOne() {
return one;
}
}
@@ -0,0 +1,60 @@
package org.tests.cascade;
import io.ebean.annotation.Cache;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Version;
@Entity
@Cache
public class OmCacheOrderedDetail {
@Id
Long id;
String name;
@ManyToOne
OmCacheOrderedMaster master;
@Version
Long version;
public OmCacheOrderedDetail(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public OmCacheOrderedMaster getMaster() {
return master;
}
public void setMaster(OmCacheOrderedMaster master) {
this.master = master;
}
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
}
@@ -0,0 +1,66 @@
package org.tests.cascade;
import io.ebean.annotation.Cache;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OrderColumn;
import javax.persistence.Version;
import java.util.List;
@Entity
@Cache
public class OmCacheOrderedMaster {
@Id
Long id;
String name;
/**
* Cascade ALL set automatically as we set order values when cascading.
*/
@OneToMany(mappedBy = "master") //, cascade = CascadeType.ALL)
@OrderColumn(name = "sort_order")
List<OmCacheOrderedDetail> details;
@Version
Long version;
public OmCacheOrderedMaster(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<OmCacheOrderedDetail> getDetails() {
return details;
}
public void setDetails(List<OmCacheOrderedDetail> details) {
this.details = details;
}
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
}
@@ -0,0 +1,57 @@
package org.tests.cascade;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Version;
@Entity
public class OmOrderedDetail {
@Id
Long id;
String name;
@ManyToOne
OmOrderedMaster master;
@Version
Long version;
public OmOrderedDetail(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public OmOrderedMaster getMaster() {
return master;
}
public void setMaster(OmOrderedMaster master) {
this.master = master;
}
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
}
@@ -0,0 +1,63 @@
package org.tests.cascade;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OrderColumn;
import javax.persistence.Version;
import java.util.List;
@Entity
public class OmOrderedMaster {
@Id
Long id;
String name;
/**
* Cascade ALL set automatically as we set order values when cascading.
*/
@OneToMany(mappedBy = "master") //, cascade = CascadeType.ALL)
@OrderColumn(name="sort_order")
List<OmOrderedDetail> details;
@Version
Long version;
public OmOrderedMaster(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<OmOrderedDetail> getDetails() {
return details;
}
public void setDetails(List<OmOrderedDetail> details) {
this.details = details;
}
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
}
@@ -0,0 +1,44 @@
package org.tests.cascade;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Version;
@Entity
public class RelDetail {
@Id
Long id;
String name;
@Version
int version;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "detail")
private List<RelMaster> masterRel;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<RelMaster> getMasterRel() {
return masterRel;
}
}
@@ -0,0 +1,48 @@
package org.tests.cascade;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Version;
@Entity
public class RelMaster {
@Id
long id;
String name;
@Version
int version;
@ManyToOne(cascade = CascadeType.REMOVE)
private RelDetail detail;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public RelDetail getDetail() {
return detail;
}
public void setDetail(RelDetail detail) {
this.detail = detail;
}
}
@@ -0,0 +1,66 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.text.json.JsonContext;
import org.junit.jupiter.api.Test;
import java.util.List;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
public class TestCascadeOrphanStatelessUpdate extends BaseTestCase {
@Test
public void update() {
final CORoot orig = setup();
CORoot root = DB.find(CORoot.class, orig.getId());
assertNotNull(root);
assertThat(root.getOne().getChildren()).hasSize(3);
final JsonContext jsonContext = DB.json();
String asJson = jsonContext.toJson(root);
final CORoot deserialized = jsonContext.toBean(CORoot.class, asJson);
final COOne one = deserialized.getOne();
COOneMany removed0 = one.getChildren().remove(0);
COOneMany removed1 = one.getChildren().remove(1);
one.getChildren().add(new COOneMany("m3"));
one.getChildren().add(new COOneMany("m4"));
DB.update(deserialized);
CORoot saved = DB.find(CORoot.class, orig.getId());
assertNotNull(saved);
assertThat(saved.getOne().getChildren()).hasSize(3);
List<COOneMany> softDeleted = DB.find(COOneMany.class)
.setIncludeSoftDeletes()
.where()
.idIn(asList(removed0.getId(), removed1.getId()))
.findList();
assertThat(softDeleted).hasSize(2);
assertThat(softDeleted.stream().map(COOneMany::getId).collect(toList()))
.contains(removed0.getId(), removed1.getId());
}
private CORoot setup() {
COOne one = new COOne("one");
one.getChildren().add(new COOneMany("m0"));
one.getChildren().add(new COOneMany("m1"));
one.getChildren().add(new COOneMany("m2"));
CORoot root = new CORoot("r0", one);
DB.save(root);
return root;
}
}
@@ -0,0 +1,51 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class TestDeleteO2MOrphans extends BaseTestCase {
@Test
public void test() {
final long id = setup();
// act
setNewChildren(id);
// assert
COOne check = findById(id);
assertThat(check.getChildren()).hasSize(2);
DB.delete(check);
}
private COOne findById(long id) {
return DB.find(COOne.class).where().idEq(id).findOne();
}
private void setNewChildren(long id) {
COOne found = findById(id);
found.setChildren(createManies("M3", "M4"));
DB.update(found);
}
private long setup() {
COOne company = new COOne("P0");
company.setChildren(createManies("M1", "M2"));
DB.insert(company);
return company.getId();
}
private List<COOneMany> createManies(String name1, String name2) {
COOneMany employee1 = new COOneMany(name1);
COOneMany employee2 = new COOneMany(name2);
List<COOneMany> employees = new ArrayList<>();
employees.add(employee1);
employees.add(employee2);
return employees;
}
}
@@ -0,0 +1,27 @@
package org.tests.cascade;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class TestJsonMarshallingOTM {
@Test
public void test() {
String json = ("" +
"{ 'masterRel': [" +
" { 'name': 'a' }," +
" { 'name': 'b' }" +
"] }"
).replaceAll("'", "\"");
RelDetail bean = DB.json().toBean(RelDetail.class, json);
final RelMaster m0 = bean.getMasterRel().get(0);
assertThat(m0.getName()).isEqualTo("a");
final RelMaster m1 = bean.getMasterRel().get(1);
assertThat(m1.getName()).isEqualTo("b");
}
}
@@ -0,0 +1,83 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.Transaction;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import org.junit.jupiter.api.Test;
public class TestMasterDetailDelete extends BaseTestCase {
@Test
public void testDeleteOneMasterTxn() {
try (Transaction txn = server().beginTransaction()) {
RelDetail rd = new RelDetail();
rd.setName("test1");
server().save(rd);
RelMaster rm = new RelMaster();
rm.setDetail(rd);
server().save(rm);
List<RelDetail> lst = server().find(RelDetail.class).where().eq("name", "test1").findList();
assertThat(lst).hasSize(1);
server().find(RelMaster.class).delete();
lst = server().find(RelDetail.class).where().eq("name", "test1").findList();
assertThat(lst).isEmpty();
} // no commit
}
@Test
public void testDeleteMultiMasterTxn() {
try (Transaction txn = server().beginTransaction()) {
RelDetail rd = new RelDetail();
rd.setName("test2");
server().save(rd);
RelMaster rm1 = new RelMaster();
rm1.setDetail(rd);
server().save(rm1);
RelMaster rm2 = new RelMaster();
rm2.setDetail(rd);
server().save(rm2);
List<RelDetail> lst = server().find(RelDetail.class).where().eq("name", "test2").findList();
assertThat(lst).hasSize(1);
server().find(RelMaster.class).delete();
lst = server().find(RelDetail.class).where().eq("name", "test2").findList();
assertThat(lst).isEmpty();
} // no commit
}
@Test
public void testDeleteMultiMasterPlain() {
RelDetail rd = new RelDetail();
rd.setName("test3");
server().save(rd);
RelMaster rm1 = new RelMaster();
rm1.setDetail(rd);
server().save(rm1);
RelMaster rm2 = new RelMaster();
rm2.setDetail(rd);
server().save(rm2);
List<RelDetail> lst = server().find(RelDetail.class).where().eq("name", "test3").findList();
assertThat(lst).hasSize(1);
server().find(RelMaster.class).delete();
lst = server().find(RelDetail.class).where().eq("name", "test3").findList();
assertThat(lst).isEmpty();
}
}
@@ -0,0 +1,94 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.DB;
import io.ebean.Transaction;
import org.ebeantest.LoggedSqlCollector;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.tests.model.site.DataContainer;
import org.tests.model.site.Site;
import org.tests.model.site.SiteAddress;
import java.util.Collections;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class TestMultiCascadeBatch extends BaseTestCase {
private Transaction txn;
@BeforeEach
public void before() {
txn = DB.beginTransaction();
}
@AfterEach
public void after() {
if (txn != null) {
txn.end();
}
}
@Test
public void save() {
Site grandparent = new Site();
grandparent.setName("grandparent");
Site parent = new Site();
parent.setName("parent");
Site child = new Site();
child.setName("child");
grandparent.setChildren(Collections.singletonList(parent));
parent.setChildren(Collections.singletonList(child));
LoggedSqlCollector.start();
grandparent.save();
final List<String> sql = LoggedSqlCollector.stop();
final List<Site> list = DB.find(Site.class).where()
.idIn(grandparent.getId(), parent.getId(), child.getId())
.findList();
assertThat(list).hasSize(3);
assertThat(sql).hasSize(5);
assertSql(sql.get(0)).contains("insert into site (id, name");
assertSql(sql.get(1)).contains("insert into site (id, name");
assertSqlBind(sql.get(2));
assertThat(sql.get(3)).contains("insert into site (id, name");
assertSqlBind(sql.get(4));
}
@Test
public void testMultipleCascadeInsideTransaction() {
final Site mainSite = new Site();
mainSite.setName("mainSite");
DB.save(mainSite);
// create child including data
final Site childSite = new Site();
childSite.setName("childSite");
final SiteAddress childAddress = new SiteAddress();
childAddress.setCity("Some city");
childAddress.setStreet("some street");
childAddress.setZipCode("12345");
childSite.setSiteAddress(childAddress);
final DataContainer dataContainer = new DataContainer();
dataContainer.setContent("container content");
childSite.setDataContainer(dataContainer);
mainSite.getChildren().add(childSite);
mainSite.setName("a different name");
DB.save(mainSite);
}
}
@@ -0,0 +1,62 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
public class TestOnlyKillOrphans extends BaseTestCase {
@Test
public void test() {
final COOne one = setup();
assertThat(one.getChildren()).hasSize(2);
CORoot root = new CORoot("P1", one);
DB.insert(root);
// assert
CORoot check = DB.find(CORoot.class, root.getId());
assertThat(check.getOne().getChildren()).hasSize(2);
DB.delete(check);
}
@Test
public void test2() {
final COOne one = setup();
assertThat(one.getChildren()).hasSize(2);
one.getChildren().add(new COOneMany("_M1"));
DB.save(one);
// assert
COOne check = DB.find(COOne.class, one.getId());
assertThat(check.getChildren().stream().map(it -> it.getName()).sorted().collect(Collectors.toList()))
.isEqualTo(Stream.of("M1", "M2", "_M1").sorted().collect(Collectors.toList()));
DB.delete(check);
}
private COOne setup() {
COOne one = new COOne("P0");
one.setChildren(createManies("M1", "M2"));
DB.insert(one);
return one;
}
private List<COOneMany> createManies(String... names) {
List<COOneMany> manies = new ArrayList<>();
for (String name : names) {
manies.add(new COOneMany(name));
}
return manies;
}
}
@@ -0,0 +1,191 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.ebeantest.LoggedSqlCollector;
import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class TestOrderedList extends BaseTestCase {
@Test
public void test() {
OmOrderedMaster master = new OmOrderedMaster("m1");
List<OmOrderedDetail> details = master.getDetails();
for (int i = 0; i < 5; i++) {
details.add(new OmOrderedDetail("d"+i));
}
LoggedSqlCollector.start();
DB.save(master);
List<String> sql = LoggedSqlCollector.current();
assertThat(sql.size()).isGreaterThan(1);
assertSql(sql.get(0)).contains("insert into om_ordered_master");
boolean hasId = sql.get(1).contains(" (id, name");
if (hasId) {
assertSql(sql.get(1)).contains("insert into om_ordered_detail (id, name, version, sort_order, master_id) values (?,?,?,?,?)");
} else {
assertSql(sql.get(1)).contains("insert into om_ordered_detail (name, version, sort_order, master_id) values (?,?,?,?)");
}
// update without any changes
DB.save(master);
sql = LoggedSqlCollector.current();
assertThat(sql).isEmpty();
// update just changing master
master.setName("m1-mod");
DB.save(master);
sql = LoggedSqlCollector.current();
assertThat(sql).hasSize(1);
assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=?");
fetchAndReorder(master.getId());
}
private void fetchAndReorder(Long id) {
OmOrderedMaster fresh = DB.find(OmOrderedMaster.class).setId(id).fetch("details").findOne();
List<OmOrderedDetail> details1 = fresh.getDetails();
List<String> sql = LoggedSqlCollector.current();
assertSql(sql.get(0)).contains("order by t0.id, t1.sort_order");
// fetched, not dirty
DB.save(fresh);
sql = LoggedSqlCollector.current();
assertThat(sql).isEmpty();
// reorder
OmOrderedDetail third = details1.remove(2);
OmOrderedDetail first = details1.remove(0);
details1.add(first);
details1.add(third);
fresh.setName("m1-reorder");
DB.save(fresh);
sql = LoggedSqlCollector.current();
assertThat(sql).hasSize(7);
assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=?");
assertSql(sql.get(1)).contains("update om_ordered_detail set version=?, sort_order=? where id=? and version=?");
details1.get(1).setName("was 1");
fresh.setName("m1-mod3");
DB.save(fresh);
sql = LoggedSqlCollector.current();
assertThat(sql).hasSize(3);
assertSql(sql.get(0)).contains("update om_ordered_master set name=?, version=? where id=? and version=?; -- bind(m1-mod3");
assertSql(sql.get(1)).contains("update om_ordered_detail set name=?, version=?, sort_order=? where id=? and version=?");
assertThat(sql.get(2)).contains("bind(was 1,3,2,");
DB.delete(fresh);
sql = LoggedSqlCollector.stop();
assertThat(sql).hasSize(3);
assertSql(sql.get(0)).contains("delete from om_ordered_detail where master_id = ?");
assertSqlBind(sql.get(1));
assertSql(sql.get(2)).contains("delete from om_ordered_master where id=? and version=?");
}
@Test
public void testAddSavedDetailToMaster() {
final OmOrderedMaster master = new OmOrderedMaster("Master");
final OmOrderedDetail detail = new OmOrderedDetail("Detail");
DB.save(master);
DB.save(detail);
master.getDetails().add(detail);
DB.save(master);
final OmOrderedMaster masterDb = DB.find(OmOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).hasSize(1);
}
@Test
public void testModifyList() {
final OmOrderedMaster master = new OmOrderedMaster("Master");
final OmOrderedDetail detail1 = new OmOrderedDetail("Detail1");
final OmOrderedDetail detail2 = new OmOrderedDetail("Detail2");
final OmOrderedDetail detail3 = new OmOrderedDetail("Detail3");
DB.save(detail1);
DB.save(detail2);
DB.save(detail3);
master.getDetails().add(detail1);
master.getDetails().add(detail2);
master.getDetails().add(detail3);
DB.save(master);
OmOrderedMaster masterDb = DB.find(OmOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail1, detail2, detail3);
Collections.reverse(masterDb.getDetails());
DB.save(masterDb);
masterDb = DB.find(OmOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail3, detail2, detail1);
masterDb.getDetails().remove(1);
DB.save(masterDb);
masterDb = DB.find(OmOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail3, detail1);
}
@Test
public void testModifyListWithCache() {
final OmCacheOrderedMaster master = new OmCacheOrderedMaster("Master");
final OmCacheOrderedDetail detail1 = new OmCacheOrderedDetail("Detail1");
final OmCacheOrderedDetail detail2 = new OmCacheOrderedDetail("Detail2");
final OmCacheOrderedDetail detail3 = new OmCacheOrderedDetail("Detail3");
DB.save(detail1);
DB.save(detail2);
DB.save(detail3);
master.getDetails().add(detail1);
master.getDetails().add(detail2);
master.getDetails().add(detail3);
DB.save(master);
OmCacheOrderedMaster masterDb = DB.find(OmCacheOrderedMaster.class, master.getId()); // load cache
assertThat(masterDb.getDetails()).containsExactly(detail1, detail2, detail3);
masterDb = DB.find(OmCacheOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail1, detail2, detail3); // hit cache
Collections.reverse(masterDb.getDetails());
DB.save(masterDb);
masterDb = DB.find(OmCacheOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail3, detail2, detail1); // load cache
masterDb = DB.find(OmCacheOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail3, detail2, detail1); // hit cache
masterDb.getDetails().remove(1);
DB.save(masterDb);
masterDb = DB.find(OmCacheOrderedMaster.class, master.getId());
assertThat(masterDb.getDetails()).containsExactly(detail3, detail1);
}
}
@@ -0,0 +1,88 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.bean.BeanCollection;
import org.tests.model.basic.TSDetail;
import org.tests.model.basic.TSMaster;
import org.ebeantest.LoggedSqlCollector;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestPrivateOwned extends BaseTestCase {
@Test
public void test() {
TSMaster m0 = new TSMaster();
m0.setName("m1");
m0.addDetail(new TSDetail("m1 detail 1"));
m0.addDetail(new TSDetail("m1 detail 2"));
DB.save(m0);
TSMaster master = DB.find(TSMaster.class, m0.getId());
List<TSDetail> details = master.getDetails();
TSDetail removedDetail = details.remove(1);
BeanCollection<?> bc = (BeanCollection<?>) details;
Set<?> modifyRemovals = bc.getModifyRemovals();
assertNotNull(modifyRemovals);
assertTrue(modifyRemovals.size() == 1);
assertTrue(modifyRemovals.contains(removedDetail));
DB.save(master);
TSMaster masterReload = DB.find(TSMaster.class, m0.getId());
List<TSDetail> detailsReload = masterReload.getDetails();
// the removed bean has really been removed
assertTrue(detailsReload.size() == 1);
TSMaster master3 = DB.find(TSMaster.class, m0.getId());
List<TSDetail> details3 = master3.getDetails();
details3.clear();
}
@Test
public void insertThenUpdate() {
TSMaster m0 = new TSMaster();
m0.setName("m2");
m0.addDetail(new TSDetail("m2 detail 1"));
m0.addDetail(new TSDetail("m2 detail 2"));
DB.save(m0);
assertThat(m0.getDetails()).hasSize(2);
LoggedSqlCollector.start();
m0.getDetails().remove(0);
DB.save(m0);
List<String> loggedSql = LoggedSqlCollector.stop();
assertThat(loggedSql).hasSize(2);
assertThat(loggedSql.get(0)).contains("delete from t_detail_with_other_namexxxyy where id=?");
assertSqlBind(loggedSql.get(1));
TSMaster masterReload = DB.find(TSMaster.class, m0.getId());
assertThat(masterReload.getDetails()).hasSize(1);
LoggedSqlCollector.start();
DB.save(m0);
loggedSql = LoggedSqlCollector.stop();
assertThat(loggedSql).hasSize(0);
}
}
@@ -0,0 +1,34 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.basic.TSDetail;
import org.tests.model.basic.TSMaster;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestPrivateOwnedAddRemoveOrphan extends BaseTestCase {
@Test
public void test() {
// setup
TSMaster master0 = new TSMaster();
DB.save(master0);
// act
TSMaster master1 = DB.find(master0.getClass(), master0.getId());
TSDetail tsDetail = new TSDetail();
// Add then remove a bean that was never saved (to the DB)
master1.getDetails().add(tsDetail);
master1.getDetails().remove(tsDetail);
DB.save(master1);
TSMaster master2 = DB.find(master1.getClass(), master1.getId());
assertTrue(master2.getDetails().isEmpty());
}
}
@@ -0,0 +1,61 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.Transaction;
import org.junit.jupiter.api.Test;
import org.tests.model.basic.TSDetail;
import org.tests.model.basic.TSMaster;
public class TestPrivateOwnedCascadeOrder extends BaseTestCase {
@Test
public void test() {
// setup
TSMaster master = new TSMaster();
master.getDetails().add(new TSDetail("c97", "ONE"));
master.getDetails().add(new TSDetail("c96", "TWO"));
DB.save(master);
// act
TSMaster master1 = DB.find(master.getClass(), master.getId());
// Check Ebean deletes the existing c97 first as the unique values clash
master1.getDetails().clear();
master1.getDetails().add(new TSDetail("c98", "TWO"));
DB.save(master1);
}
@Test
public void testWithTransaction() {
// setup
TSMaster master = new TSMaster();
master.getDetails().add(new TSDetail("d97", "ONE2"));
master.getDetails().add(new TSDetail("d96", "TWO2"));
DB.save(master);
// act
TSMaster master1 = DB.find(master.getClass(), master.getId());
// Check Ebean deletes the existing d96 first as the unique values clash
Transaction transaction = DB.beginTransaction();
try {
master1.getDetails().clear();
master1.getDetails().add(new TSDetail("d98", "TWO2"));
DB.save(master1);
transaction.commit();
} finally {
transaction.end();
}
// Cleanup
DB.find(TSDetail.class).where().or().eq("name", "d97").eq("name", "d98").delete();
DB.delete(master1);
}
}
@@ -0,0 +1,48 @@
package org.tests.cascade;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.basic.TSDetail;
import org.tests.model.basic.TSMaster;
import org.junit.jupiter.api.Test;
import javax.persistence.OptimisticLockException;
import static org.assertj.core.api.Assertions.fail;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestPrivateOwnedIgnoreTransientOrphan extends BaseTestCase {
@Test
public void test() {
/** new object **/
TSMaster master0 = new TSMaster();
/** recovered after first save **/
TSMaster master1 = null;
/** recovered after transient child ignored **/
TSMaster master2 = null;
DB.save(master0);
master1 = DB.find(master0.getClass(), master0.getId());
// Add then remove a bean that was never saved (to the DB)
master1.getDetails().add(new TSDetail());
master1.getDetails().clear();
try {
DB.save(master1);
} catch (OptimisticLockException exception) {
// Occured when the "unsaved" bean was wrongly being deleted
fail("Optimistic lock exception wrongly thrown: " + exception.getMessage());
return;
}
master2 = master1 = DB.find(master1.getClass(), master1.getId());
assertTrue(master2.getDetails().isEmpty());
}
}