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,110 @@
package org.tests.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicJsonJackson;
import org.tests.model.json.EBasicJsonJackson2;
import org.tests.model.json.LongJacksonType;
import org.tests.model.json.StringJacksonType;
import java.io.IOException;
import static org.assertj.core.api.Assertions.assertThat;
public class TestDbJson_Jackson extends BaseTestCase {
/**
* This testcase verifies if the @JsonDeserialize Annotation will work properly in ebean.
*/
@Test
public void testJsonDeserializeAnnotation() throws IOException {
EBasicJsonJackson bean = new EBasicJsonJackson();
bean.setName("stuff");
bean.setPlainValue("plain");
bean.getValueSet().add("A");
bean.getValueSet().add("B");
bean.getValueList().add("A");
bean.getValueList().add("B");
bean.getValueMap().put(1, "one");
bean.getValueMap().put(2, "two");
ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
String json = mapper.writeValueAsString(bean);
EBasicJsonJackson found = mapper.readValue(json, EBasicJsonJackson.class);
// here we assert, that we can serialize/deserialize that bean with jackson
assertThat(found.getPlainValue()).isEqualTo("plain");
assertThat(found.getValueList()).containsExactly("A", "B");
assertThat(found.getValueSet()).containsExactly("A", "B");
assertThat(found.getValueMap()).containsEntry(1L, "one").containsEntry(2L, "two");
DB.save(bean);
// here we do the same and expect, that we can deserialize the bean also
found = DB.find(EBasicJsonJackson.class, bean.getId());
assertThat(found.getPlainValue()).isEqualTo("plain");
assertThat(found.getValueList()).containsExactly("A", "B");
assertThat(found.getValueSet()).containsExactly("A", "B");
assertThat(found.getValueMap()).containsEntry(1L, "one").containsEntry(2L, "two");
}
/**
* This testcase verifies if polymorph objects will work in ebean.
*
* for BasicJacksonType there exists two types and has a @JsonTypeInfo
* annotation. It is expected that this information is also honored by ebean.
*/
@Test
public void testPolymorph() throws IOException {
EBasicJsonJackson2 bean = new EBasicJsonJackson2();
bean.setName("stuff");
bean.setPlainValue(new LongJacksonType(42L));
bean.getValueSet().add(new StringJacksonType("A"));
bean.getValueSet().add(new LongJacksonType(7l));
bean.getValueList().add(new StringJacksonType("A"));
bean.getValueList().add(new LongJacksonType(7l));
bean.getValueMap().put(1, new StringJacksonType("A"));
bean.getValueMap().put(2, new LongJacksonType(7l));
ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
String json = mapper.writeValueAsString(bean);
assertThat(json)
.contains("\"type\":\"string\"")
.contains("\"type\":\"long\"");
EBasicJsonJackson2 found = mapper.readValue(json, EBasicJsonJackson2.class);
assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
assertThat(found.getValueList()).hasSize(2);
assertThat(found.getValueSet()).hasSize(2);
assertThat(found.getValueMap()).hasSize(2);;
DB.save(bean);
found = DB.find(EBasicJsonJackson2.class, bean.getId());
assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
assertThat(found.getValueList()).hasSize(2);
assertThat(found.getValueSet()).hasSize(2);
assertThat(found.getValueMap()).hasSize(2);;
}
}
@@ -0,0 +1,59 @@
package org.tests.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicJsonJackson2;
import org.tests.model.json.LongJacksonType;
import org.tests.model.json.StringJacksonType;
import java.io.IOException;
import static org.assertj.core.api.Assertions.assertThat;
public class TestDbJson_Jackson2 extends BaseTestCase {
private EBasicJsonJackson2 bean = new EBasicJsonJackson2();
private EBasicJsonJackson2 found;
@Test
public void insert() throws IOException {
bean.setName("stuff");
bean.setPlainValue(new LongJacksonType(42L));
bean.getValueSet().add(new StringJacksonType("A"));
bean.getValueSet().add(new LongJacksonType(7l));
bean.getValueList().add(new StringJacksonType("A"));
bean.getValueList().add(new LongJacksonType(7l));
bean.getValueMap().put(1, new StringJacksonType("A"));
bean.getValueMap().put(2, new LongJacksonType(7l));
ObjectMapper mapper = (ObjectMapper) DB.getDefault().pluginApi().config().getObjectMapper();
String json = mapper.writeValueAsString(bean);
found = mapper.readValue(json, EBasicJsonJackson2.class);
assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
assertThat(found.getValueList()).hasSize(2);
assertThat(found.getValueSet()).hasSize(2);
assertThat(found.getValueMap()).hasSize(2);;
DB.save(bean);
found = DB.find(EBasicJsonJackson2.class, bean.getId());
assertThat(found.getPlainValue()).isInstanceOf(LongJacksonType.class);
assertThat(found.getValueList()).hasSize(2);
assertThat(found.getValueSet()).hasSize(2);
assertThat(found.getValueMap()).hasSize(2);;
}
}
@@ -0,0 +1,246 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.BeanState;
import io.ebean.DB;
import io.ebean.ValuePair;
import io.ebean.annotation.IgnorePlatform;
import io.ebean.annotation.Platform;
import io.ebean.event.BeanPersistAdapter;
import io.ebean.event.BeanPersistRequest;
import io.ebeantest.LoggedSql;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicJsonJackson3;
import org.tests.model.json.EBasicJsonList;
import org.tests.model.json.EBasicJsonMulti;
import org.tests.model.json.PlainBean;
import org.tests.model.json.PlainBeanDirtyAware;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
public class TestDbJson_Jackson3 extends BaseTestCase {
public static class EBasicJsonListPersistController extends BeanPersistAdapter {
private static Map<String, ValuePair> updatedValues;
@Override
public boolean isRegisterFor(Class<?> cls) {
return EBasicJsonList.class.isAssignableFrom(cls);
}
@Override
public boolean preInsert(BeanPersistRequest<?> request) {
updatedValues = request.updatedValues();
return true;
}
@Override
public boolean preUpdate(BeanPersistRequest<?> request) {
updatedValues = request.updatedValues();
return true;
}
}
@IgnorePlatform(Platform.MYSQL)
@Test
public void updateIncludesJsonColumn_when_explicit_isMarkedDirty() {
PlainBeanDirtyAware contentBean = new PlainBeanDirtyAware("a", 42);
EBasicJsonJackson3 bean = new EBasicJsonJackson3();
bean.setName("b1");
bean.setPlainValue(contentBean);
bean.setPlainValue2(contentBean);
bean.save();
final EBasicJsonJackson3 found = DB.find(EBasicJsonJackson3.class, bean.getId());
found.setName("b1-mod");
LoggedSql.start();
found.save();
expectedSql(0, "update ebasic_json_jackson3 set name=?, version=? where id=? and version=?");
found.setName("b1-mod2");
found.getPlainValue().setName("b");
// found.getPlainValue().setMarkedDirty(true); // Irrelevant for SOURCE or HASH based mutation detection
found.save();
expectedSql(0, "update ebasic_json_jackson3 set name=?, plain_value=?, version=? where id=? and version=?");
LoggedSql.stop();
final EBasicJsonJackson3 found2 = DB.find(EBasicJsonJackson3.class, bean.getId());
assertThat(found2.getName()).isEqualTo("b1-mod2");
assertThat(found2.getPlainValue().getName()).isEqualTo("b");
}
@IgnorePlatform(Platform.MYSQL)
@Test
public void updateIncludesJsonColumn_when_loadedAndNotDirtyAware() {
PlainBean contentBean = new PlainBean("a", 42);
EBasicJsonList bean = new EBasicJsonList();
bean.setName("p1");
bean.setPlainBean(contentBean);
bean.setBeanList(Arrays.asList(contentBean));
DB.save(bean);
final EBasicJsonList found = DB.find(EBasicJsonList.class, bean.getId());
// json bean not modified but not aware
// ideally don't load the json content if we are not going to modify it
found.setName("p1-mod");
found.setBeanList(null);
BeanState state = DB.beanState(found);
assertThat(state.changedProps()).containsExactlyInAnyOrder("name", "beanList");
ValuePair pair = state.dirtyValues().get("name");
assertThat(pair.getNewValue()).isEqualTo("p1-mod");
assertThat(pair.getOldValue()).isEqualTo("p1");
pair = state.dirtyValues().get("beanList");
assertThat(pair.getNewValue()).isEqualTo(null);
assertThat((List<PlainBean>) pair.getOldValue()).hasSize(1)
.extracting(PlainBean::getName).containsExactly("a");
LoggedSql.start();
DB.save(found);
// plain_bean=?, no longer included with MD5 dirty detection
expectedSql(0, "update ebasic_json_list set name=?, bean_list=?, version=? where id=?");
assertThat(EBasicJsonListPersistController.updatedValues.entrySet())
.extracting(Map.Entry::toString)
.containsExactlyInAnyOrder("beanList=null,[name:a]", "name=p1-mod,p1", "version=2,1");
assertThat(DB.beanState(found).isDirty()).isFalse();
found.getPlainBean().setName("b");
assertThat(DB.beanState(found).isDirty()).isTrue();
state = DB.beanState(found);
assertThat(state.changedProps()).containsExactlyInAnyOrder("plainBean");
pair = state.dirtyValues().get("plainBean");
assertThat(pair.getNewValue()).hasToString("name:b");
assertThat(pair.getOldValue()).hasToString("name:a");
LoggedSql.start();
DB.save(found);
// plain_bean=?, no longer included with MD5 dirty detection
expectedSql(0, "update ebasic_json_list set plain_bean=?, version=? where id=?");
assertThat(EBasicJsonListPersistController.updatedValues.entrySet())
.extracting(Map.Entry::toString)
.containsExactlyInAnyOrder("plainBean=name:b,name:a", "version=3,2");
LoggedSql.stop();
}
@IgnorePlatform(Platform.MYSQL)
@Test
public void updateIncludesJsonColumn_when_list_loadedAndNotDirtyAware() {
PlainBean contentBean = new PlainBean("a", 42);
EBasicJsonList bean = new EBasicJsonList();
bean.setName("p1");
bean.setPlainBean(contentBean);
bean.setBeanList(Arrays.asList(contentBean));
DB.save(bean);
final EBasicJsonList found = DB.find(EBasicJsonList.class, bean.getId());
found.getBeanList().get(0).setName("p1-mod");
BeanState state = DB.beanState(found);
assertThat(state.changedProps()).containsExactlyInAnyOrder("beanList");
}
@IgnorePlatform(Platform.MYSQL)
@Test
public void update_with_differentDbJsonSettings() {
PlainBeanDirtyAware contentBean1 = new PlainBeanDirtyAware("x", 42);
PlainBeanDirtyAware contentBean2 = new PlainBeanDirtyAware("y", 43);
PlainBeanDirtyAware contentBean3 = new PlainBeanDirtyAware("z", 44);
EBasicJsonJackson3 bean = new EBasicJsonJackson3();
bean.setName("b1");
bean.setPlainValue(contentBean1);
bean.setPlainValue2(contentBean2);
bean.setPlainValue3(contentBean3);
BeanState state = DB.beanState(bean);
// a new bean is not considered as dirty (thus have no changed props)
assertThat(state.isDirty()).isFalse();
assertThat(state.isNewOrDirty()).isTrue();
assertThat(state.changedProps()).isEmpty();
bean.save();
bean = DB.find(EBasicJsonJackson3.class, bean.getId());
state = DB.beanState(bean);
// a fresh loaded bean is also not considered as dirty
assertThat(state.isDirty()).isFalse();
assertThat(state.isNewOrDirty()).isFalse();
assertThat(state.changedProps()).isEmpty();
bean.getPlainValue().setName("a"); // has SOURCE
assertThat(state.isDirty()).isTrue();
assertThat(state.changedProps()).containsExactly("plainValue");
bean.getPlainValue2().setName("b");
assertThat(state.changedProps()).containsExactlyInAnyOrder("plainValue", "plainValue2");
bean.getPlainValue3().setName("c"); // has mutationDetection = NONE
Map<String, ValuePair> dirtyValues = state.dirtyValues();
assertThat(dirtyValues).hasSize(2).containsKeys("plainValue", "plainValue2");
assertThat(dirtyValues.get("plainValue")).hasToString("name:a,name:x"); // SOURCE -> origValue present
assertThat(dirtyValues.get("plainValue2")).hasToString("name:b,null"); // without SOURCE no origValue present
LoggedSql.start();
bean.save();
expectedSql(0, "update ebasic_json_jackson3 set plain_value=?, plain_value2=?, version=? where id=?");
bean = DB.find(EBasicJsonJackson3.class, bean.getId());
LoggedSql.collect(); // ignore the select
assertThat(bean.getPlainValue().getName()).isEqualTo("a");
assertThat(bean.getPlainValue2().getName()).isEqualTo("b");
assertThat(bean.getPlainValue3().getName()).isEqualTo("z"); // value is not updated
bean.getPlainValue3().setName("c");
bean.getPlainValue3().setMarkedDirty(true); // This is ignored because it is MutationDetection.NONE
bean.save();
// no update as plainValue3 has MutationDetection.NONE (ModifyAwareType = NONE isn't an expected combination to me)
assertThat(LoggedSql.collect()).isEmpty();
bean.getPlainValue2().setName("b2"); // effectively HASH mode mutation detection
bean.save();
expectedSql(0, "update ebasic_json_jackson3 set plain_value2=?, version=? where id=? and version=?");
LoggedSql.stop();
}
@Test
public void push_pop_test() {
EBasicJsonMulti bean = new EBasicJsonMulti();
bean.setPlainValue2(new PlainBeanDirtyAware("x", 42));
bean.save();
bean = DB.find(EBasicJsonMulti.class, bean.getId());
bean.setPlainValue1(null); // already null
bean.setPlainValue2(null);
bean.setPlainValue3(null); // already null
BeanState state = DB.beanState(bean);
assertThat(state.dirtyValues()).hasSize(1).containsKey("plainValue2");
}
private void expectedSql(int i, String s) {
assertThat(LoggedSql.collect().get(i)).contains(s);
}
}
@@ -0,0 +1,238 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.annotation.ForPlatform;
import io.ebean.annotation.Platform;
import io.ebean.text.TextException;
import org.ebeantest.LoggedSqlCollector;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicJsonList;
import org.tests.model.json.PlainBean;
import javax.persistence.PersistenceException;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
public class TestDbJson_List extends BaseTestCase {
private final EBasicJsonList bean = new EBasicJsonList();
private EBasicJsonList found;
@Test
public void insert() {
bean.setName("stuff");
bean.getTags().add("one");
bean.getTags().add("two");
bean.getFlags().add(42L);
bean.getFlags().add(43L);
bean.getFlags().add(44L);
bean.setPlainBean(new PlainBean("plain", 52));
List<PlainBean> beanList = new ArrayList<>();
beanList.add(new PlainBean("one", 1));
beanList.add(new PlainBean("two", 2));
bean.setBeanList(beanList);
Set<PlainBean> beanSet = new LinkedHashSet<>();
beanSet.add(new PlainBean("A", 1));
beanSet.add(new PlainBean("B", 2));
bean.setBeanSet(beanSet);
bean.getBeanMap().put("key0", new PlainBean("k0", 90));
bean.getBeanMap().put("key1", new PlainBean("k1", 91));
DB.save(bean);
found = DB.find(EBasicJsonList.class, bean.getId());
assertThat(found.getTags()).containsExactly("one", "two");
assertTrue(found.getFlags().contains(42L));
assertTrue(found.getFlags().contains(43L));
assertTrue(found.getFlags().contains(44L));
assertThat(found.getBeanList()).hasSize(2);
assertThat(found.getBeanSet()).hasSize(2);
assertThat(found.getBeanMap()).hasSize(2);
assertThat(found.getPlainBean().getName()).isEqualTo("plain");
assertThat(found.getPlainBean().getAlong()).isEqualTo(52);
json_parse_format();
update_when_notDirty();
update_when_dirty();
update_when_dirty_flags();
update_when_dirty_SetListMap();
DB.delete(found);
}
private void json_parse_format() {
String asJson = DB.json().toJson(found);
assertThat(asJson).contains("\"tags\":[\"one\",\"two\"]");
assertThat(asJson).contains("\"flags\":[42,43,44]");
assertThat(asJson).contains("\"plainBean\":{\"name\":\"plain\"");
assertThat(asJson).contains("\"beanSet\":[");
assertThat(asJson).contains("\"beanList\":[");
assertThat(asJson).contains("\"beanMap\":{");
assertThat(asJson).contains("\"id\":");
EBasicJsonList fromJson = DB.json().toBean(EBasicJsonList.class, asJson);
assertEquals(found.getId(), fromJson.getId());
assertEquals(found.getId(), fromJson.getId());
assertEquals(found.getName(), fromJson.getName());
assertThat(fromJson.getTags()).containsExactly("one", "two");
assertTrue(fromJson.getFlags().contains(42L));
assertTrue(fromJson.getFlags().contains(43L));
assertTrue(fromJson.getFlags().contains(44L));
assertThat(fromJson.getBeanSet()).hasSize(2);
assertThat(fromJson.getBeanList()).hasSize(2);
assertThat(fromJson.getBeanMap()).hasSize(2);
}
private void update_when_notDirty() {
found.setName("mod");
LoggedSqlCollector.start();
DB.save(found);
List<String> sql = LoggedSqlCollector.stop();
// we don't update the phone numbers (as they are not dirty)
// plain_bean=?, no longer included with dirty detection
if (!isMySql()) {
assertSql(sql.get(0)).contains("update ebasic_json_list set name=?, version=? where");
}
}
private void update_when_dirty() {
//found.setName("modAgain");
found.getTags().add("three");
LoggedSqlCollector.start();
DB.save(found);
List<String> sql = LoggedSqlCollector.stop();
// we don't update the phone numbers (as they are not dirty)
// plain_bean=? not included using MD5 dirty detection
assertSql(sql.get(0)).contains("update ebasic_json_list set tags=?, version=? where id=? and version=?");
}
private void update_when_dirty_flags() {
//found.setName("modAgain");
found.getFlags().remove(42L);
LoggedSqlCollector.start();
DB.save(found);
List<String> sql = LoggedSqlCollector.stop();
// we don't update the phone numbers (as they are not dirty)
// plain_bean=? not included with MD5 dirty detection
assertSql(sql.get(0)).contains("update ebasic_json_list set flags=?, version=? where id=? and version=?;");
}
private void update_when_dirty_SetListMap() {
//found.setName("modAgain");
found.getBeanSet().clear();
found.getBeanList().clear();
found.getBeanMap().remove("key0");
LoggedSqlCollector.start();
DB.save(found);
List<String> sql = LoggedSqlCollector.stop();
// we don't update the phone numbers (as they are not dirty)
// plain_bean=? not included with MD5 dirty detection
assertSql(sql.get(0)).contains("update ebasic_json_list set beans=?, bean_list=?, bean_map=?, version=? where id=? and version=?");
}
@Test
public void insert_fetch_when_null() {
EBasicJsonList bean = new EBasicJsonList();
bean.setName("leave some nulls");
bean.setFlags(null);
bean.setTags(null);
bean.setBeanMap(null);
DB.save(bean);
EBasicJsonList found = DB.find(EBasicJsonList.class, bean.getId());
assertNull(found.getPlainBean());
String asJson = DB.json().toJson(found);
assertNotNull(asJson);
}
@ForPlatform(Platform.H2)
@Test
public void find_corrupt_json_using_setAllowLoadErrors() {
EBasicJsonList bean = new EBasicJsonList();
PlainBean plainBean = new PlainBean();
plainBean.setName("Blubb");
bean.getBeanMap().put("bla", plainBean);
DB.save(bean);
// set some invalid JSON content into DB
DB.sqlUpdate("update ebasic_json_list set bean_map=? where id=?")
.setParameters("blabla", bean.getId())
.execute();
try {
// a normal query fails due to invalid JSON content
DB.find(EBasicJsonList.class)
.setId(bean.getId())
.findOne();
fail("never get here");
} catch (PersistenceException e) {
// query fails due to error loading invalid JSON content
assertThat(e.getMessage()).contains("beanMap");
}
bean = DB.find(EBasicJsonList.class)
.setId(bean.getId())
.setAllowLoadErrors() // allow invalid JSON content
.findOne();
Map<String, Exception> errors = server().beanState(bean).loadErrors();
assertThat(errors).containsKey("beanMap").hasSize(1);
assertThat(errors.values().iterator().next())
.isInstanceOf(TextException.class)
.hasMessageContaining("blabla");
DB.delete(bean);
}
@Test
public void testNullToEmpty() {
EBasicJsonList bean = new EBasicJsonList();
bean.setFlags(null);
bean.setTags(null);
bean.setBeanMap(null);
DB.save(bean);
bean = DB.find(EBasicJsonList.class).setId(bean.getId()).findOne();
assertThat(bean.getFlags()).isEmpty();
assertThat(bean.getTags()).isEmpty();
assertThat(bean.getBeanMap()).isEmpty();
}
}
@@ -0,0 +1,138 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.Query;
import io.ebean.text.json.EJson;
import io.ebeantest.LoggedSql;
import org.tests.model.json.EBasicJsonMap;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicJsonMapDetail;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonMapBasic extends BaseTestCase {
@Test
public void whereManyPredicate() {
if (!isPostgres()) {
// testing postgres specific select distinct on clause
return;
}
EBasicJsonMap bean = new EBasicJsonMap();
bean.setName("own1");
bean.getDetails().add(new EBasicJsonMapDetail("detail1"));
bean.getDetails().add(new EBasicJsonMapDetail("detail2"));
DB.save(bean);
Query<EBasicJsonMap> query1 = DB.find(EBasicJsonMap.class)
.fetch("details")
.where().startsWith("details.name", "detail")
.query();
query1.findList();
assertThat(query1.getGeneratedSql()).contains("select distinct on (t0.id, t1.id) ");
Query<EBasicJsonMap> query2 = DB.find(EBasicJsonMap.class)
.where().startsWith("details.name", "detail")
.query();
query2.findList();
assertThat(query2.getGeneratedSql()).contains("select distinct on (t0.id) ");
}
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
//String s1 = "{\"docId\":19,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMap bean = new EBasicJsonMap();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonMap bean1 = DB.find(EBasicJsonMap.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType"));
assertEquals(18L, bean1.getContent().get("docId"));
bean1.setName("just change name");
DB.save(bean1);
// content changes detected - dirty state so included in update
Map<String, Object> content1 = bean1.getContent();
content1.put("additional", "newValue");
content1.put("docId", 99L);
bean1.setName("two");
DB.save(bean1);
EBasicJsonMap bean2 = DB.find(EBasicJsonMap.class, bean.getId());
// name changed and docId changed
assertEquals("two", bean2.getName());
assertEquals(99L, bean2.getContent().get("docId"));
assertEquals("newValue", bean2.getContent().get("additional"));
content1.put("additional", "modValue");
bean1.setName("three");
bean1.setContent(content1);
DB.save(bean1);
EBasicJsonMap bean3 = DB.find(EBasicJsonMap.class, bean.getId());
assertEquals("three", bean3.getName());
assertEquals(99L, bean3.getContent().get("docId"));
assertEquals("modValue", bean3.getContent().get("additional"));
}
@Test
public void updateQuery_bindingMap() throws IOException {
String s0 = "{\"docId\":22,\"contentId\":\"initialDoc\"}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMap bean = new EBasicJsonMap();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
String s1 = "{\"docId\":222,\"contentId\":\"updatedDoc222\"}";
Map<String, Object> content1 = EJson.parseObject(s1);
LoggedSql.start();
final int rows = DB.update(EBasicJsonMap.class)
.set("content", content1)
.where().eq("id", bean.getId())
.update();
final List<String> sql = LoggedSql.stop();
assertThat(sql).hasSize(1);
assertThat(sql.get(0)).contains("update ebasic_json_map set content=? where id = ?");
assertThat(rows).isEqualTo(1);
final EBasicJsonMap found = DB.find(EBasicJsonMap.class, bean.getId());
final Map<String, Object> content2 = found.getContent();
assertThat(content2.get("contentId")).isEqualTo("updatedDoc222");
assertThat(content2.get("docId")).isEqualTo(222L);
DB.delete(found);
}
}
@@ -0,0 +1,39 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.text.json.EJson;
import org.tests.model.json.EBasicJsonMapBlob;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonMapBlob extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMapBlob bean = new EBasicJsonMapBlob();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonMapBlob bean1 = DB.find(EBasicJsonMapBlob.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType"));
assertEquals(18L, bean1.getContent().get("docId"));
bean1.setName("just change name");
DB.save(bean1);
}
}
@@ -0,0 +1,39 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.text.json.EJson;
import org.tests.model.json.EBasicJsonMapClob;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonMapClob extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMapClob bean = new EBasicJsonMapClob();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonMapClob bean1 = DB.find(EBasicJsonMapClob.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType"));
assertEquals(18L, bean1.getContent().get("docId"));
bean1.setName("just change name");
DB.save(bean1);
}
}
@@ -0,0 +1,39 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.text.json.EJson;
import org.tests.model.json.EBasicJsonMapJsonB;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonMapJsonB extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMapJsonB bean = new EBasicJsonMapJsonB();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonMapJsonB bean1 = DB.find(EBasicJsonMapJsonB.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType"));
assertEquals(18L, bean1.getContent().get("docId"));
bean1.setName("just change name");
DB.save(bean1);
}
}
@@ -0,0 +1,39 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.text.json.EJson;
import org.tests.model.json.EBasicJsonMapVarchar;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonMapVarchar extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
Map<String, Object> content = EJson.parseObject(s0);
EBasicJsonMapVarchar bean = new EBasicJsonMapVarchar();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonMapVarchar bean1 = DB.find(EBasicJsonMapVarchar.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().get("contentType"), bean1.getContent().get("contentType"));
assertEquals(18L, bean1.getContent().get("docId"));
bean1.setName("just change name");
DB.save(bean1);
}
}
@@ -0,0 +1,134 @@
package org.tests.json;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.SerializationFeature;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.basic.Order;
import org.tests.model.json.EBasicJsonNode;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
public class TestJsonNodeBasic extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
String s1 = "{\"docId\":99,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNode bean = new EBasicJsonNode();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonNode bean1 = DB.find(EBasicJsonNode.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().path("contentType").asText(), bean1.getContent().path("contentType").asText());
assertEquals(18L, bean1.getContent().get("docId").asLong());
bean1.setName("just change name");
DB.save(bean1);
JsonNode content1 = objectMapper.readTree(s1);
bean1.setName("two");
bean1.setContent(content1);
DB.save(bean1);
EBasicJsonNode bean2 = DB.find(EBasicJsonNode.class, bean.getId());
// name changed and docId changed
assertEquals("two", bean2.getName());
assertEquals(99L, bean2.getContent().path("docId").asLong());
// content persisted even though it has not changed (as it's loaded)
// we can't do dirty detection on JsonNode (like we do on Map<String,Object>)
bean1.setName("three");
DB.save(bean1);
EBasicJsonNode bean3 = DB.find(EBasicJsonNode.class, bean.getId());
assertEquals("three", bean3.getName());
assertEquals(99L, bean3.getContent().path("docId").asLong());
// write whole bean with content as JSON
String fullBeanJson = DB.json().toJson(bean3);
// parse JSON into whole bean with content
EBasicJsonNode beanJsonRestored = DB.json().toBean(EBasicJsonNode.class, fullBeanJson);
assertEquals(99L, beanJsonRestored.getContent().path("docId").asLong());
}
@Test
public void testLazyLoading() throws IOException {
String s0 = "{\"docId\":19,\"contentId\":\"asd\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNode bean = new EBasicJsonNode();
bean.setName("lazyLoadTest");
bean.setContent(content);
DB.save(bean);
EBasicJsonNode bean1 = DB.find(EBasicJsonNode.class)
.select("name")
.setId(bean.getId())
.findOne();
Set<String> loadedProps = DB.beanState(bean1).loadedProps();
assertTrue(loadedProps.contains("name"));
assertFalse(loadedProps.contains("content"));
assertNotNull(bean1.getContent());
}
@Test
public void testJacksonEnum_WRITE_ENUMS_USING_INDEX() throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.enable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
JsonFactory jsonFactory = objectMapper.getFactory();
StringWriter writer = new StringWriter();
JsonGenerator generator = jsonFactory.createGenerator(writer);
generator.writeStartObject();
generator.writeFieldName("status");
generator.writeObject(Order.Status.APPROVED);
generator.writeEndObject();
generator.flush();
assertThat(writer.toString()).isEqualTo("{\"status\":1}");
JsonParser parser = jsonFactory.createParser("1");
Order.Status status = parser.readValueAs(Order.Status.class);
assertThat(status).isEqualTo(Order.Status.APPROVED);
}
}
@@ -0,0 +1,67 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.json.EBasicJsonNodeBlob;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class TestJsonNodeBlob extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeBlob bean = new EBasicJsonNodeBlob();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeBlob bean1 = DB.find(EBasicJsonNodeBlob.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().path("contentType").asText(), bean1.getContent().path("contentType").asText());
assertEquals(18L, bean1.getContent().get("docId").asLong());
}
@Test
public void testLazyLoading() throws IOException {
String s0 = "{\"docId\":19,\"contentId\":\"asd\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeBlob bean = new EBasicJsonNodeBlob();
bean.setName("lazyLoadTest");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeBlob bean1 = DB.find(EBasicJsonNodeBlob.class)
.select("name")
.setId(bean.getId())
.findOne();
Set<String> loadedProps = DB.beanState(bean1).loadedProps();
assertTrue(loadedProps.contains("name"));
assertFalse(loadedProps.contains("content"));
assertNotNull(bean1.getContent());
}
}
@@ -0,0 +1,67 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.json.EBasicJsonNodeJsonB;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class TestJsonNodeJsonb extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeJsonB bean = new EBasicJsonNodeJsonB();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeJsonB bean1 = DB.find(EBasicJsonNodeJsonB.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().path("contentType").asText(), bean1.getContent().path("contentType").asText());
assertEquals(18L, bean1.getContent().get("docId").asLong());
}
@Test
public void testLazyLoading() throws IOException {
String s0 = "{\"docId\":19,\"contentId\":\"asd\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeJsonB bean = new EBasicJsonNodeJsonB();
bean.setName("lazyLoadTest");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeJsonB bean1 = DB.find(EBasicJsonNodeJsonB.class)
.select("name")
.setId(bean.getId())
.findOne();
Set<String> loadedProps = DB.beanState(bean1).loadedProps();
assertTrue(loadedProps.contains("name"));
assertFalse(loadedProps.contains("content"));
assertNotNull(bean1.getContent());
}
}
@@ -0,0 +1,66 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.json.EBasicJsonNodeVarchar;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
public class TestJsonNodeVarchar extends BaseTestCase {
@Test
public void testInsertUpdateDelete() throws IOException {
String s0 = "{\"docId\":18,\"contentId\":\"asd\",\"active\":true,\"contentType\":\"pg-hello\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeVarchar bean = new EBasicJsonNodeVarchar();
bean.setName("one");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeVarchar bean1 = DB.find(EBasicJsonNodeVarchar.class, bean.getId());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
assertEquals(bean.getContent().path("contentType").asText(), bean1.getContent().path("contentType").asText());
assertEquals(18L, bean1.getContent().get("docId").asLong());
}
@Test
public void testLazyLoading() throws IOException {
String s0 = "{\"docId\":19,\"contentId\":\"asd\",\"content\":{\"name\":\"rob\",\"age\":45}}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode content = objectMapper.readTree(s0);
EBasicJsonNodeVarchar bean = new EBasicJsonNodeVarchar();
bean.setName("lazyLoadTest");
bean.setContent(content);
DB.save(bean);
EBasicJsonNodeVarchar bean1 = DB.find(EBasicJsonNodeVarchar.class)
.select("name")
.setId(bean.getId())
.findOne();
Set<String> loadedProps = DB.beanState(bean1).loadedProps();
assertTrue(loadedProps.contains("name"));
assertFalse(loadedProps.contains("content"));
assertNotNull(bean1.getContent());
}
}
@@ -0,0 +1,66 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicOldValue;
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
public class TestJsonNullValues extends BaseTestCase {
@Test
public void testSetToNull() {
EBasicOldValue bean = new EBasicOldValue();
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
bean.setStringList(null);
bean.setStringSet(null);
bean.setObjectMap(null);
bean.setLongList(null);
bean.setLongSet(null);
bean.setLongMap(null);
bean.setIntList(null);
bean.setIntSet(null);
bean.setIntMap(null);
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
assertThat(bean.getStringList()).isEmpty();
assertThat(bean.getStringSet()).isEmpty();
assertThat(bean.getObjectMap()).isEmpty();
assertThat(bean.getLongList()).isEmpty();
assertThat(bean.getLongSet()).isEmpty();
assertThat(bean.getLongMap()).isEmpty();
assertThat(bean.getIntList()).isEmpty();
assertThat(bean.getIntSet()).isEmpty();
assertThat(bean.getIntMap()).isEmpty();
}
@Test
public void testSetOneToNullAnotherToEmpty() {
EBasicOldValue bean = new EBasicOldValue();
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
bean.setStringList(null);
bean.setStringSet(null);
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
bean.setStringList(new ArrayList<>());
bean.setStringSet(null);
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
assertThat(bean.getStringList()).isEmpty();
assertThat(bean.getStringSet()).isEmpty();
}
}
@@ -0,0 +1,106 @@
package org.tests.json;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.ValuePair;
import org.assertj.core.api.SoftAssertions;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.tests.model.json.EBasicOldValue;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class TestOldValue extends BaseTestCase {
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testDbJsonOldValue() {
EBasicOldValue bean = new EBasicOldValue();
JsonNodeFactory jnf = new JsonNodeFactory(false);
bean.getStringList().add("sl1");
bean.getStringSet().add("ss1");
bean.getObjectMap().put("sk1","sm1");
bean.getLongList().add(1L);
bean.getLongSet().add(1001L);
bean.getLongMap().put("lk1",2001L);
bean.getIntList().add(2);
bean.getIntSet().add(1002);
bean.getIntMap().put("ik1",2002);
bean.setJsonNode(jnf.arrayNode().add("Foo"));
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
bean.getStringList().add("sl2");
bean.getStringSet().add("ss2");
bean.getObjectMap().put("sk2","sm2");
bean.getLongList().add(5L);
bean.getLongSet().add(1005L);
bean.getLongMap().put("lk2",2005L);
bean.getIntList().add(6);
bean.getIntSet().add(1006);
bean.getIntMap().put("ik2",2006);
((ArrayNode)bean.getJsonNode()).add("Bar");
Map<String, ValuePair> dirty = DB.beanState(bean).dirtyValues();
SoftAssertions softly = new SoftAssertions();
softly.assertThat(dirty).hasSize(10);
softly.assertThat((List)dirty.get("stringList").getOldValue()).containsExactly("sl1");
softly.assertThat((List)dirty.get("stringList").getNewValue()).containsExactly("sl1", "sl2");
softly.assertThat((List)dirty.get("longList").getOldValue()).containsExactly(1L);
softly.assertThat((List)dirty.get("longList").getNewValue()).containsExactly(1L, 5L);
softly.assertThat((List)dirty.get("intList").getOldValue()).containsExactly(2);
softly.assertThat((List)dirty.get("intList").getNewValue()).containsExactly(2, 6);
softly.assertThat((Set)dirty.get("stringSet").getOldValue()).containsExactly("ss1");
softly.assertThat((Set)dirty.get("stringSet").getNewValue()).containsExactly("ss1", "ss2");
softly.assertThat((Set)dirty.get("longSet").getOldValue()).containsExactly(1001L);
softly.assertThat((Set)dirty.get("longSet").getNewValue()).containsExactly(1001L, 1005L);
softly.assertThat((Set)dirty.get("intSet").getOldValue()).containsExactly(1002);
softly.assertThat((Set)dirty.get("intSet").getNewValue()).containsExactly(1002, 1006);
softly.assertThat((Map)dirty.get("objectMap").getOldValue()).containsEntry("sk1","sm1").hasSize(1);
softly.assertThat((Map)dirty.get("objectMap").getNewValue()).containsEntry("sk1","sm1").containsEntry("sk2","sm2").hasSize(2);
softly.assertThat((Map)dirty.get("longMap").getOldValue()).containsEntry("lk1",2001L).hasSize(1);
softly.assertThat((Map)dirty.get("longMap").getNewValue()).containsEntry("lk1",2001L).containsEntry("lk2",2005L).hasSize(2);
softly.assertThat((Map)dirty.get("intMap").getOldValue()).containsEntry("ik1",2002).hasSize(1);
softly.assertThat((Map)dirty.get("intMap").getNewValue()).containsEntry("ik1",2002).containsEntry("ik2",2006).hasSize(2);
softly.assertThat((ArrayNode)dirty.get("jsonNode").getOldValue()).hasToString("[\"Foo\"]");
softly.assertThat((ArrayNode)dirty.get("jsonNode").getNewValue()).hasToString("[\"Foo\",\"Bar\"]");
softly.assertAll();
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
@Disabled("Old value detection does not work for @DbArray")
public void testDbArrayOldValue() {
EBasicOldValue bean = new EBasicOldValue();
bean.getStringArr().add("sa1");
DB.save(bean);
bean = DB.find(EBasicOldValue.class, bean.getId());
bean.getStringArr().add("sa2");
Map<String, ValuePair> dirty = DB.beanState(bean).dirtyValues();
SoftAssertions softly = new SoftAssertions();
softly.assertThat(dirty).hasSize(1);
softly.assertThat((List)dirty.get("stringArr").getOldValue()).containsExactly("sa1");
softly.assertThat((List)dirty.get("stringArr").getNewValue()).containsExactly("sa1", "sa2");
softly.assertAll();
}
}
@@ -0,0 +1,54 @@
package org.tests.json;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.json.EBasicJsonUnmapped;
import org.junit.jupiter.api.Test;
import java.util.LinkedHashMap;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
public class TestUnmappedProperties extends BaseTestCase {
@Test
public void toJson() {
Map<String,Object> nested = new LinkedHashMap<>();
nested.put("alpha", "aa");
nested.put("beta", "bb");
Map<String,Object> unmapped = new LinkedHashMap<>();
unmapped.put("one", 42);
unmapped.put("nested", nested);
EBasicJsonUnmapped bean = new EBasicJsonUnmapped();
bean.setName("someName");
bean.setUnmapped(unmapped);
String asJson = DB.json().toJson(bean);
assertThat(asJson).contains("{\"name\":\"someName\",\"one\":42,\"nested\":{\"alpha\":\"aa\",\"beta\":\"bb\"}}");
}
@Test
public void fromJson() {
String json = "{\"name\":\"someName\",\"one\":42,\"nested\":{\"alpha\":\"aa\",\"beta\":\"bb\"}}";
EBasicJsonUnmapped bean = DB.json().toBean(EBasicJsonUnmapped.class, json);
assertThat(bean.getName()).isEqualTo("someName");
assertThat(bean.getUnmapped().get("one")).isEqualTo(42L);
@SuppressWarnings("unchecked")
Map<String,Object> fromNested = (Map<String,Object>)bean.getUnmapped().get("nested");
assertThat(fromNested).containsKeys("alpha", "beta");
assertThat(fromNested).containsValues("aa", "bb");
}
}
@@ -0,0 +1,52 @@
package org.tests.json.include;
import io.ebean.DB;
import io.ebean.config.JsonConfig;
import io.ebean.text.json.JsonWriteOptions;
import org.tests.model.basic.Order;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonExcludeEmptyList {
@Test
public void testToBeanToJson_NonNull() throws Exception {
Order bean = new Order();
bean.setId(99);
bean.setStatus(null);
bean.setOrderDate(null);
bean.setDetails(new ArrayList<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_NULL);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99,\"details\":[]}";
assertEquals(expectedJson, asJson);
}
@Test
public void testToBeanToJson_NonEmpty() throws Exception {
Order bean = new Order();
bean.setId(99);
bean.setStatus(null);
bean.setOrderDate(null);
bean.setDetails(new ArrayList<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_EMPTY);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99}";
assertEquals(expectedJson, asJson);
}
}
@@ -0,0 +1,48 @@
package org.tests.json.include;
import io.ebean.DB;
import io.ebean.config.JsonConfig;
import io.ebean.text.json.JsonWriteOptions;
import org.tests.model.json.EBasicJsonMap;
import org.junit.jupiter.api.Test;
import java.util.LinkedHashMap;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonExcludeEmptyMap {
@Test
public void testToBeanToJson_NonNull() throws Exception {
EBasicJsonMap bean = new EBasicJsonMap();
bean.setId(99L);
bean.setContent(new LinkedHashMap<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_NULL);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99,\"content\":{}}";
assertEquals(expectedJson, asJson);
}
@Test
public void testToBeanToJson_NonEmpty() throws Exception {
EBasicJsonMap bean = new EBasicJsonMap();
bean.setId(99L);
bean.setContent(new LinkedHashMap<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_EMPTY);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99,\"content\":{}}";
assertEquals(expectedJson, asJson);
}
}
@@ -0,0 +1,48 @@
package org.tests.json.include;
import io.ebean.DB;
import io.ebean.config.JsonConfig;
import io.ebean.text.json.JsonWriteOptions;
import org.tests.model.basic.AttributeHolder;
import org.junit.jupiter.api.Test;
import java.util.LinkedHashSet;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonExcludeEmptySet {
@Test
public void testToBeanToJson_NonNull() throws Exception {
AttributeHolder bean = new AttributeHolder();
bean.setId(99);
bean.setAttributes(new LinkedHashSet<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_NULL);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99,\"attributes\":[]}";
assertEquals(expectedJson, asJson);
}
@Test
public void testToBeanToJson_NonEmpty() throws Exception {
AttributeHolder bean = new AttributeHolder();
bean.setId(99);
bean.setAttributes(new LinkedHashSet<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_EMPTY);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99}";
assertEquals(expectedJson, asJson);
}
}
@@ -0,0 +1,31 @@
package org.tests.json.include;
import io.ebean.DB;
import io.ebean.config.JsonConfig;
import io.ebean.text.json.JsonWriteOptions;
import org.tests.json.transientproperties.EJsonTransientObject;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonExcludeNull {
@Test
public void testToBeanToJson() throws Exception {
EJsonTransientObject bean = new EJsonTransientObject();
bean.setId(99L);
bean.setName(null);
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_NULL);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99}";
assertEquals(expectedJson, asJson);
}
}
@@ -0,0 +1,65 @@
package org.tests.json.include;
import io.ebean.DB;
import io.ebean.config.JsonConfig;
import io.ebean.text.PathProperties;
import io.ebean.text.json.JsonWriteOptions;
import org.tests.json.transientproperties.EJsonTransientEntityList;
import org.tests.json.transientproperties.EJsonTransientList;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJsonExcludeTransientEmptyList {
@Test
public void testToBeanToJson_NonNull() throws Exception {
EJsonTransientList bean = new EJsonTransientList();
bean.setId(99L);
bean.setFileNames(new ArrayList<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_NULL);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99,\"fileNames\":[]}";
assertEquals(expectedJson, asJson);
}
@Test
public void testToBeanToJson_NonEmpty() throws Exception {
EJsonTransientList bean = new EJsonTransientList();
bean.setId(99L);
bean.setFileNames(new ArrayList<>());
JsonWriteOptions options = new JsonWriteOptions();
options.setInclude(JsonConfig.Include.NON_EMPTY);
String asJson = DB.json().toJson(bean, options);
String expectedJson = "{\"id\":99}";
assertEquals(expectedJson, asJson);
}
@Test
public void testToJson_with_transientExcludeFromPathProperties() throws Exception {
EJsonTransientEntityList bean = new EJsonTransientEntityList();
bean.setId(99L);
bean.setName("John");
PathProperties pathProps = PathProperties.parse("id,name");
String asJson = DB.json().toJson(bean, pathProps);
assertThat(asJson).isEqualTo("{\"id\":99,\"name\":\"John\"}");
}
}
@@ -0,0 +1,44 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import com.fasterxml.jackson.annotation.JsonIgnore;
import javax.persistence.Entity;
import javax.persistence.Id;
@Sql
@Entity
public class EJsonJacksonIgnore {
@Id
private Long id;
private String name;
@JsonIgnore
private Boolean basic;
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 Boolean getBasic() {
return basic;
}
public void setBasic(Boolean basic) {
this.basic = basic;
}
}
@@ -0,0 +1,57 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import org.tests.model.basic.Order;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;
import java.util.List;
@Sql
@Entity
public class EJsonTransientEntityList {
@Id
private Long id;
private String name;
@Transient
private Boolean basic;
@Transient
private List<Order> orders;
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 Boolean getBasic() {
return basic;
}
public void setBasic(Boolean basic) {
this.basic = basic;
}
public List<Order> getOrders() {
return orders;
}
public void setOrders(List<Order> orders) {
this.orders = orders;
}
}
@@ -0,0 +1,57 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;
import java.util.List;
@Sql
@Entity
public class EJsonTransientList {
@Id
private Long id;
private String name;
@Transient
private Boolean basic;
@Transient
private List<String> fileNames;
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 Boolean getBasic() {
return basic;
}
public void setBasic(Boolean basic) {
this.basic = basic;
}
public List<String> getFileNames() {
return fileNames;
}
public void setFileNames(List<String> fileNames) {
this.fileNames = fileNames;
}
}
@@ -0,0 +1,63 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;
@Sql
@Entity
public class EJsonTransientObject {
@Id
private Long id;
private String name;
@Transient
private Boolean basic;
@Transient
private SomeBean someBean;
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 Boolean getBasic() {
return basic;
}
public void setBasic(Boolean basic) {
this.basic = basic;
}
public SomeBean getSomeBean() {
return someBean;
}
public void setSomeBean(SomeBean someBean) {
this.someBean = someBean;
}
public static class SomeBean {
public String name;
public String baz;
}
}
@@ -0,0 +1,46 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;
import java.util.List;
@Sql
@Entity
public class ModelA {
@Id
int id;
String a;
// transient mapping to an entity bean
@Transient
List<ModelB> list;
public String getA() {
return a;
}
public void setA(String a) {
this.a = a;
}
public List<ModelB> getList() {
return list;
}
public void setList(List<ModelB> list) {
this.list = list;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
@@ -0,0 +1,31 @@
package org.tests.json.transientproperties;
import io.ebean.annotation.Sql;
import javax.persistence.Entity;
@Sql
@Entity
public class ModelB {
Integer oneField;
Integer twoField;
public Integer getOneField() {
return oneField;
}
public void setOneField(Integer oneField) {
this.oneField = oneField;
}
public Integer getTwoField() {
return twoField;
}
public void setTwoField(Integer twoField) {
this.twoField = twoField;
}
}
@@ -0,0 +1,40 @@
package org.tests.json.transientproperties;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class TestJacksonIgnore {
@Test
public void testJacksonJsonIgnoreAnnotation() throws Exception {
EJsonJacksonIgnore bean = new EJsonJacksonIgnore();
bean.setId(99L);
bean.setName("foo");
bean.setBasic(Boolean.TRUE);
String asJson = DB.json().toJson(bean);
// ignored on write
assertFalse(asJson.contains("basic"));
EJsonJacksonIgnore bean1 = DB.json().toBean(EJsonJacksonIgnore.class, asJson);
assertNull(bean1.getBasic());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
// ignored on read
String jsonFull = "{\"id\":99,\"name\":\"foo\",\"basic\":true}";
bean1 = DB.json().toBean(EJsonJacksonIgnore.class, jsonFull);
assertNull(bean1.getBasic());
assertEquals(bean.getId(), bean1.getId());
assertEquals(bean.getName(), bean1.getName());
}
}
@@ -0,0 +1,34 @@
package org.tests.json.transientproperties;
import io.ebean.DB;
import io.ebean.text.PathProperties;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.assertj.core.api.Assertions.assertThat;
public class TestModelAJson {
@Test
public void test() {
ModelA a = new ModelA();
a.setId(1);
a.setA("a");
ModelB b = new ModelB();
b.setOneField(1);
b.setTwoField(1);
a.setList(new ArrayList<>());
a.getList().add(b);
PathProperties pathProperties = PathProperties.parse("(a,list(oneField))");
String json = DB.json().toJson(a, pathProperties);
assertThat(json).isEqualTo("{\"a\":\"a\",\"list\":[{\"oneField\":1}]}");
}
}
@@ -0,0 +1,25 @@
package org.tests.json.transientproperties;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestTransientListProperty {
@Test
public void testWithTransientListProperty() throws Exception {
String rawJson = "{\"basic\":true,\"fileNames\":[\"1\"]}";
EJsonTransientList bean = DB.json().toBean(EJsonTransientList.class, rawJson);
assertEquals(true, bean.getBasic());
assertEquals(1, bean.getFileNames().size());
String asJson = DB.json().toJson(bean);
assertEquals(rawJson, asJson);
}
}
@@ -0,0 +1,27 @@
package org.tests.json.transientproperties;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestTransientObjectProperty {
@Test
public void testToBeanToJson() throws Exception {
String rawJson = "{\"name\":\"entityBeanName\",\"basic\":true,\"someBean\":{\"name\":\"transientBeanName\",\"baz\":\"foo\"}}";
EJsonTransientObject bean = DB.json().toBean(EJsonTransientObject.class, rawJson);
assertEquals("entityBeanName", bean.getName());
assertEquals(true, bean.getBasic());
assertEquals("transientBeanName", bean.getSomeBean().name);
assertEquals("foo", bean.getSomeBean().baz);
String asJson = DB.json().toJson(bean);
assertEquals(rawJson, asJson);
}
}