mirror of
https://github.com/ebean-orm/ebean.git
synced 2026-11-19 23:02:24 +00:00
Refactor move tests from ebean-core to ebean-test
This commit is contained in:
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);
|
||||
}
|
||||
|
||||
}
|
||||
+65
@@ -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;
|
||||
}
|
||||
}
|
||||
+57
@@ -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}]}");
|
||||
|
||||
}
|
||||
}
|
||||
+25
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
+27
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user