#919 - io.ebean package initial

src/test/java/org/tests/text/csv/TestCsvReader.java

@@ -0,0 +1,48 @@
+package org.tests.text.csv;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.csv.CsvReader;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileReader;
+import java.net.URL;
+import java.util.Locale;
+
+public class TestCsvReader extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    try {
+      URL resource = TestCsvReaderWithCallback.class.getResource("/test1.csv");
+      File f = new File(resource.getFile());
+
+      FileReader reader = new FileReader(f);
+
+      CsvReader<Customer> csvReader = Ebean.createCsvReader(Customer.class);
+
+      csvReader.setPersistBatchSize(2);
+
+      csvReader.addIgnore();
+      // csvReader.addProperty("id");
+      csvReader.addProperty("status");
+      csvReader.addProperty("name");
+      csvReader.addDateTime("anniversary", "dd-MMM-yyyy", Locale.GERMAN);
+      csvReader.addProperty("billingAddress.line1");
+      csvReader.addProperty("billingAddress.city");
+      csvReader.addProperty("billingAddress.country.code");
+
+      csvReader.process(reader);
+
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+}

src/test/java/org/tests/text/csv/TestCsvReaderWithCallback.java

@@ -0,0 +1,59 @@
+package org.tests.text.csv;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.text.csv.CsvReader;
+import io.ebean.text.csv.DefaultCsvCallback;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileReader;
+import java.net.URL;
+import java.util.Locale;
+
+public class TestCsvReaderWithCallback extends BaseTestCase {
+
+  @Test
+  public void test() throws Throwable {
+
+    ResetBasicData.reset();
+
+    URL resource = TestCsvReaderWithCallback.class.getResource("/test1.csv");
+    File f = new File(resource.getFile());
+
+    FileReader reader = new FileReader(f);
+
+    final EbeanServer server = Ebean.getServer(null);
+
+    CsvReader<Customer> csvReader = server.createCsvReader(Customer.class);
+
+    csvReader.setPersistBatchSize(2);
+    csvReader.setLogInfoFrequency(3);
+
+    csvReader.addIgnore();
+    // csvReader.addProperty("id");
+    csvReader.addProperty("status");
+    csvReader.addProperty("name");
+    csvReader.addDateTime("anniversary", "dd-MMM-yyyy", Locale.GERMAN);
+    csvReader.addProperty("billingAddress.line1");
+    csvReader.addProperty("billingAddress.city");
+    // processor.addReference("billingAddress.country.code");
+    csvReader.addProperty("billingAddress.country.code");
+
+    csvReader.process(reader, new DefaultCsvCallback<Customer>() {
+
+      @Override
+      public void processBean(int row, String[] lineContent, Customer cust) {
+
+        server.save(cust.getBillingAddress(), transaction);
+        server.save(cust, transaction);
+      }
+
+    });
+
+  }
+
+}

src/test/java/org/tests/text/csv/TestTimeStringParser.java

@@ -0,0 +1,37 @@
+package org.tests.text.csv;
+
+import io.ebean.BaseTestCase;
+import io.ebean.text.TimeStringParser;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Time;
+
+public class TestTimeStringParser extends BaseTestCase {
+
+  @Test
+  public void testSimple() {
+
+    Time t = (Time) TimeStringParser.get().parse("12:00");
+    Assert.assertNotNull(t);
+
+    t = (Time) TimeStringParser.get().parse("12:00:12");
+    Assert.assertNotNull(t);
+
+    expectError("12");
+    expectError("12:");
+    expectError("12:00:");
+    expectError("12:00::");
+    expectError("12:00:00:");
+
+  }
+
+  private void expectError(String value) {
+    try {
+      TimeStringParser.get().parse(value);
+      Assert.assertTrue(false);
+    } catch (IllegalArgumentException e) {
+      Assert.assertTrue(true);
+    }
+  }
+}

src/test/java/org/tests/text/json/TestJsonBeanDescriptorParse.java

@@ -0,0 +1,47 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.text.json.ReadJson;
+import org.tests.model.basic.Customer;
+import com.fasterxml.jackson.core.JsonParser;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.Set;
+
+public class TestJsonBeanDescriptorParse extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+
+    BeanDescriptor<Customer> descriptor = server.getBeanDescriptor(Customer.class);
+
+
+    StringReader reader = new StringReader("{\"id\":123,\"name\":\"Hello rob\"}");
+    JsonParser parser = server.json().createParser(reader);
+
+    ReadJson readJson = new ReadJson(descriptor, parser, null, null);
+
+    Customer customer = descriptor.jsonRead(readJson, null);
+
+    Assert.assertEquals(Integer.valueOf(123), customer.getId());
+    Assert.assertEquals("Hello rob", customer.getName());
+
+    BeanState beanState = Ebean.getBeanState(customer);
+    Set<String> loadedProps = beanState.getLoadedProps();
+
+    Assert.assertEquals(2, loadedProps.size());
+    Assert.assertTrue(loadedProps.contains("id"));
+    Assert.assertTrue(loadedProps.contains("name"));
+
+  }
+
+}

src/test/java/org/tests/text/json/TestJsonBeanWithTimeZone.java

@@ -0,0 +1,44 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.BeanWithTimeZone;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.TimeZone;
+
+public class TestJsonBeanWithTimeZone extends BaseTestCase {
+
+  @Test
+  public void testSimple() throws IOException {
+
+    TimeZone defaultTimeZone = TimeZone.getDefault();
+
+    TimeZone.getAvailableIDs(defaultTimeZone.getRawOffset());
+
+    String id = defaultTimeZone.getID();
+    TimeZone timeZone = TimeZone.getTimeZone(id);
+    Assert.assertEquals(defaultTimeZone, timeZone);
+
+    BeanWithTimeZone bean = new BeanWithTimeZone();
+    bean.setName("foo");
+    bean.setTimezone(TimeZone.getDefault());
+
+    JsonContext jsonContext = Ebean.json();
+    String jsonContent = jsonContext.toJson(bean);
+
+    BeanWithTimeZone bean2 = jsonContext.toBean(BeanWithTimeZone.class, jsonContent);
+
+    Assert.assertEquals(bean.getTimezone(), bean2.getTimezone());
+
+    Ebean.save(bean);
+    BeanWithTimeZone bean3 = Ebean.find(BeanWithTimeZone.class, bean.getId());
+
+    Assert.assertEquals(bean.getTimezone(), bean3.getTimezone());
+
+  }
+
+}

src/test/java/org/tests/text/json/TestJsonInheritanceDiscriminator.java

@@ -0,0 +1,62 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.Animal;
+import org.tests.model.basic.Cat;
+import org.tests.model.basic.Dog;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.sql.Date;
+import java.util.List;
+
+public class TestJsonInheritanceDiscriminator extends BaseTestCase {
+
+  @Test
+  public void testNoDiscriminator() throws IOException {
+
+    Cat cat = new Cat();
+    cat.setName("Gemma");
+
+    Ebean.save(cat);
+
+    JsonContext json = Ebean.json();
+    String jsonContent = json.toJson(cat);
+
+    Cat cat2 = json.toBean(Cat.class, jsonContent);
+
+    Assert.assertEquals(cat.getId(), cat2.getId());
+    Assert.assertEquals(cat.getName(), cat2.getName());
+    Assert.assertEquals(cat.getVersion(), cat2.getVersion());
+
+    String noDiscriminator = "{\"id\":1,\"name\":\"Gemma\",\"version\":1}";
+
+    Cat cat3 = json.toBean(Cat.class, noDiscriminator);
+
+    Assert.assertEquals(1L, cat3.getId().longValue());
+    Assert.assertEquals("Gemma", cat3.getName());
+    Assert.assertEquals(1L, cat3.getVersion().longValue());
+
+    Dog dog = new Dog();
+    dog.setRegistrationNumber("ABC123");
+    dog.setDateOfBirth(new Date(System.currentTimeMillis()));
+
+    Ebean.save(dog);
+
+    List<Animal> animals = Ebean.find(Animal.class).findList();
+
+    String listJson = json.toJson(animals);
+
+    List<Animal> animals2 = json.toList(Animal.class, listJson);
+    Assert.assertEquals(animals.size(), animals2.size());
+
+    String noDiscList = "[{\"id\":1,\"name\":\"Gemma\",\"version\":1},{\"name\":\"PussCat\",\"version\":1},{\"species\":\"CAT\",\"name\":\"PussCat\",\"version\":1}]";
+    List<Cat> cats = json.toList(Cat.class, noDiscList);
+    Assert.assertEquals(cats.size(), 3);
+
+  }
+
+}

src/test/java/org/tests/text/json/TestJsonMap.java

@@ -0,0 +1,79 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.PathProperties;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonWriteOptions;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertTrue;
+
+public class TestJsonMap extends BaseTestCase {
+
+  @Test
+  public void test_basic() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> customers = Ebean.find(Customer.class).findList();
+
+    JsonContext jsonContext = Ebean.json();
+
+    JsonWriteOptions jsonWriteOptions = JsonWriteOptions.parsePath("(id,status,name)");
+    String jsonString = jsonContext.toJson(customers, jsonWriteOptions);
+    assertTrue(jsonString.contains("{\"id\":1,\"status\":\"NEW\",\"name\":\"Rob\"}"));
+
+    jsonWriteOptions = JsonWriteOptions.parsePath("status,name");
+    jsonString = jsonContext.toJson(customers, jsonWriteOptions);
+    assertTrue(jsonString.contains("{\"status\":\"NEW\",\"name\":\"Rob\"}"));
+
+  }
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    Map<String, Customer> map = Ebean.find(Customer.class).findMap();
+
+    JsonContext jsonContext = Ebean.json();
+    JsonWriteOptions options = JsonWriteOptions.parsePath("(id,status,name)");
+
+    jsonContext.toJson(map, options);
+
+    options = JsonWriteOptions.parsePath("(id,status,name,shippingAddress(id,line1,city),billingAddress(*),contacts(*))");
+
+    jsonContext.toJson(map, options);
+
+    // Assert.assertTrue(jsonString.indexOf("{\"1\":") > -1);
+    // Assert.assertTrue(jsonString.indexOf("{\"id\":1,\"status\":\"NEW\",\"name\":\"Rob\"},")
+    // > -1);
+  }
+
+
+  @Test
+  public void test_applyPathToQuery() throws IOException {
+
+    ResetBasicData.reset();
+
+    PathProperties pathProperties =
+      PathProperties.parse("(id,status,name,shippingAddress(id,line1,city),billingAddress(*),contacts(*))");
+
+    List<Customer> customers = Ebean.find(Customer.class)
+      .apply(pathProperties)
+      .findList();
+
+    Ebean.json().toJson(customers, pathProperties);
+
+    // Assert.assertTrue(jsonString.indexOf("{\"1\":") > -1);
+    // Assert.assertTrue(jsonString.indexOf("{\"id\":1,\"status\":\"NEW\",\"name\":\"Rob\"},")
+    // > -1);
+  }
+}

src/test/java/org/tests/text/json/TestJsonSimple.java

@@ -0,0 +1,64 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.EJson;
+import io.ebean.text.json.JsonContext;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.LineNumberReader;
+import java.io.Reader;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class TestJsonSimple extends BaseTestCase {
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void test() throws IOException {
+
+    InputStream is = this.getClass().getResourceAsStream("/example1.json");
+
+    final Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+    LineNumberReader lineReader = new LineNumberReader(reader);
+
+    String readLine;
+
+    StringBuilder sb = new StringBuilder();
+    while ((readLine = lineReader.readLine()) != null) {
+      sb.append(readLine);
+    }
+
+    String jsonText = sb.toString();
+
+    Object el = EJson.parse(jsonText);
+
+    Map<String, Object> e2 = EJson.parseObject("{\"a\":12, \"name\":{\"first\":\"rob\", \"last\":\"byg\"}}");
+
+    Assert.assertEquals(12L, e2.get("a"));
+    Assert.assertEquals("rob", ((Map<String, Object>) e2.get("name")).get("first"));
+
+    Map<String, String> m = new LinkedHashMap<>();
+    m.put("hello", "rob");
+    m.put("test", "me");
+
+    JsonContext jsonContext = Ebean.json();
+    jsonContext.toJson(m);
+
+    String s = "{\"parishId\":\"18\",\"contentId\":null,\"contentStatus\":null,\"contentType\":\"pg-hello\",\"content\":\"asd\"}";
+
+    Object jsonElement = EJson.parse(s);
+    Assert.assertNotNull(jsonElement);
+
+    Map<String, Object> e3 = EJson.parseObject("{\"name\":\"\\u60a8\\u597d\"}");
+
+    Assert.assertTrue(((String) e3.get("name")).length() == 2);
+
+  }
+
+}

src/test/java/org/tests/text/json/TestJsonSomeEnumWithToString.java

@@ -0,0 +1,34 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.SomeEnum;
+import org.tests.model.basic.SomeEnumBean;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+
+public class TestJsonSomeEnumWithToString extends BaseTestCase {
+
+  @Test
+  public void testJsonConversion() throws IOException {
+
+    SomeEnumBean bean = new SomeEnumBean();
+    bean.setId(100l);
+    bean.setName("Some name");
+    bean.setSomeEnum(SomeEnum.ALPHA);
+
+    JsonContext json = Ebean.json();
+    String jsonContent = json.toJson(bean);
+
+    SomeEnumBean bean2 = json.toBean(SomeEnumBean.class, jsonContent);
+
+    Assert.assertEquals(bean.getSomeEnum(), bean2.getSomeEnum());
+    Assert.assertEquals(bean.getName(), bean2.getName());
+    Assert.assertEquals(bean.getId(), bean2.getId());
+
+  }
+
+}

src/test/java/org/tests/text/json/TestTextJsonBeanReadVisitor.java

@@ -0,0 +1,43 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.List;
+
+public class TestTextJsonBeanReadVisitor extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name, status, shippingAddress")
+      .fetch("billingAddress", "line1, city")
+      .fetch("billingAddress.country", "*")
+      .fetch("contacts", "firstName,email")
+      .order().desc("id").findList();
+
+    JsonContext json = Ebean.json();
+
+
+    String s = json.toJson(list);
+
+    List<Customer> mList = json.toList(Customer.class, s);
+
+    StringReader reader = new StringReader(s);
+    List<Customer> mList2 = json.toList(Customer.class, reader);
+
+    Assert.assertEquals(mList.size(), mList2.size());
+  }
+
+
+}

src/test/java/org/tests/text/json/TestTextJsonCompoundType.java

@@ -0,0 +1,55 @@
+package org.tests.text.json;
+
+//import java.util.Currency;
+//
+//import org.junit.Assert;
+
+import io.ebean.BaseTestCase;
+import org.junit.Test;
+
+//
+//import com.avaje.ebean.Ebean;
+//import com.avaje.ebean.text.json.JsonContext;
+//import com.avaje.tests.model.ddd.DExhEntity;
+//import com.avaje.tests.model.ddd.DPerson;
+//import com.avaje.tests.model.ivo.CMoney;
+//import com.avaje.tests.model.ivo.ExhangeCMoneyRate;
+//import com.avaje.tests.model.ivo.Money;
+//import com.avaje.tests.model.ivo.Oid;
+//import com.avaje.tests.model.ivo.Rate;
+
+public class TestTextJsonCompoundType extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+//    Currency NZD = Currency.getInstance("NZD");
+//
+//    DPerson p = new DPerson();
+//    p.setFirstName("first");
+//    p.setLastName("last");
+//    p.setSalary(new Money("12200"));
+//    p.setCmoney(new CMoney(new Money("12"), NZD));
+//
+//    JsonContext jsonContext = Ebean.createJsonContext();
+//
+//    String jsonString = jsonContext.toJson(p, true);
+//    System.out.println(jsonString);
+//
+//    CMoney cm = new CMoney(new Money("12"), NZD);
+//
+//    Rate rate = new Rate(0.1);
+//    ExhangeCMoneyRate exh = new ExhangeCMoneyRate(rate, cm);
+//
+//    DExhEntity ep = new DExhEntity();
+//    ep.setOid(new Oid<DExhEntity>(112));
+//    ep.setExhange(exh);
+//
+//    String jsonString0 = jsonContext.toJson(ep, true);
+//    System.out.println(jsonString0);
+//
+//    DExhEntity bean0 = jsonContext.toBean(DExhEntity.class, jsonString0);
+//    Assert.assertNotNull(bean0);
+
+  }
+}

src/test/java/org/tests/text/json/TestTextJsonInheritance.java

@@ -0,0 +1,58 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.CarAccessory;
+import org.tests.model.basic.CarFuse;
+import org.tests.model.basic.Trip;
+import org.tests.model.basic.Truck;
+import org.tests.model.basic.Vehicle;
+import org.tests.model.basic.VehicleDriver;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonInheritance extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    setupData();
+
+    List<Vehicle> list = Ebean.find(Vehicle.class).setAutoTune(false).findList();
+
+    Assert.assertEquals(2, list.size());
+
+    JsonContext jsonContext = Ebean.json();
+    String jsonString = jsonContext.toJson(list);
+
+    List<Vehicle> rebuiltList = jsonContext.toList(Vehicle.class, jsonString);
+
+    Assert.assertEquals(2, rebuiltList.size());
+
+  }
+
+  private void setupData() {
+
+    Ebean.createUpdate(CarAccessory.class, "delete from CarAccessory").execute();
+    Ebean.createUpdate(CarFuse.class, "delete from CarFuse").execute();
+    Ebean.createUpdate(Trip.class, "delete from trip").execute();
+    Ebean.createUpdate(VehicleDriver.class, "delete from vehicleDriver").execute();
+    Ebean.createUpdate(Vehicle.class, "delete from vehicle").execute();
+
+    Car c = new Car();
+    c.setLicenseNumber("C6788");
+    c.setDriver("CarDriver");
+    Ebean.save(c);
+
+    Truck t = new Truck();
+    t.setLicenseNumber("T1098");
+    t.setCapacity(20D);
+    Ebean.save(t);
+
+  }
+}

src/test/java/org/tests/text/json/TestTextJsonInsertUpdate.java

@@ -0,0 +1,40 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import io.ebeaninternal.server.lib.util.StringHelper;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.IOException;
+
+public class TestTextJsonInsertUpdate extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    String json0 = "{\"name\":\"InsJson\",\"status\":\"NEW\"}";
+
+    JsonContext jsonContext = Ebean.json();
+
+    // insert
+    Customer c0 = jsonContext.toBean(Customer.class, json0);
+    Ebean.save(c0);
+
+    // update with optimistic concurrency checking
+    String j0 = jsonContext.toJson(c0);
+    String j1 = StringHelper.replaceString(j0, "InsJson", "Mod1");
+    Customer c1 = jsonContext.toBean(Customer.class, j1);
+    Ebean.update(c1);
+
+    // update with no optimistic concurrency checking
+    String j2 = "{\"id\":" + c0.getId() + ",\"name\":\"ModIns\",\"status\":\"ACTIVE\"}";
+    Customer c2 = jsonContext.toBean(Customer.class, j2);
+    Ebean.update(c2);
+
+  }
+}

src/test/java/org/tests/text/json/TestTextJsonInvokeLazy.java

@@ -0,0 +1,28 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonWriteOptions;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonInvokeLazy extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class).select("name").findList();
+
+    JsonWriteOptions opt = JsonWriteOptions.parsePath("name, status");
+
+    JsonContext jsonContext = Ebean.json();
+    jsonContext.toJson(list, opt);
+  }
+}

src/test/java/org/tests/text/json/TestTextJsonReadManyLazyLoad.java

@@ -0,0 +1,82 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.text.PathProperties;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonWriteOptions;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonReadManyLazyLoad extends BaseTestCase {
+
+  @Test
+  public void test_lazyLoadBoth() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class).select("id, status, shippingAddress").order()
+      .desc("id").findList();
+
+    JsonContext json = Ebean.json();
+
+    // test that lazy loading on
+    PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
+    JsonWriteOptions o = new JsonWriteOptions();
+    o.setPathProperties(pp);
+
+    String s = json.toJson(list, o);
+    Assert.assertTrue(s.contains("\"contacts\""));
+    Assert.assertTrue(s.contains("\"name\""));
+
+  }
+
+  @Test
+  public void test_lazyLoadCust() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class).select("id, status, shippingAddress")
+      .fetch("contacts").order().desc("id").findList();
+
+    JsonContext json = Ebean.json();
+
+    // test that lazy loading on
+    PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
+    JsonWriteOptions o = new JsonWriteOptions();
+    o.setPathProperties(pp);
+
+    String s = json.toJson(list, o);
+    Assert.assertTrue(s.contains("\"contacts\""));
+    Assert.assertTrue(s.contains("\"name\""));
+
+  }
+
+  @Test
+  public void test_lazyLoadContacts() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class).select("id, name, status, shippingAddress")
+      // .fetch("contacts")
+      .order().desc("id").findList();
+
+    JsonContext json = Ebean.json();
+
+    // test that lazy loading on
+    PathProperties pp = PathProperties.parse("(id,name,contacts(firstName))");
+    JsonWriteOptions o = new JsonWriteOptions();
+    o.setPathProperties(pp);
+
+    String s = json.toJson(list, o);
+    Assert.assertTrue(s.contains("\"contacts\""));
+    Assert.assertTrue(s.contains("\"name\""));
+
+  }
+
+}

src/test/java/org/tests/text/json/TestTextJsonReferenceBean.java

@@ -0,0 +1,83 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import io.ebean.bean.EntityBean;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonWriteOptions;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Product;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonReferenceBean extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+
+    JsonContext jsonContext = Ebean.json();
+
+    Product product = Ebean.getReference(Product.class, 1);
+
+    BeanState beanState0 = Ebean.getBeanState(product);
+    if (!beanState0.isReference()) {
+      // got a cached value from beanCache
+
+    } else {
+
+      String jsonString = jsonContext.toJson(product);
+
+      Product refProd = jsonContext.toBean(Product.class, jsonString);
+
+      BeanDescriptor<Product> prodDesc = server.getBeanDescriptor(Product.class);
+      EntityBean eb = (EntityBean) refProd;
+      prodDesc.isReference(eb._ebean_getIntercept());
+
+      BeanState beanState = Ebean.getBeanState(refProd);
+      Assert.assertTrue(beanState.isNew());
+
+      String name = refProd.getName();
+      Assert.assertNull(name);
+
+      // Set to be 'loaded' to invoke lazy loading
+      beanState.setLoaded();
+      String name2 = refProd.getName();
+      Assert.assertNotNull(name2);
+
+    }
+
+    List<Order> orders = Ebean.find(Order.class)
+      // .setUseCache(false)
+      .select("status, orderDate, shipDate, customer").fetch("details", "*")
+      // .fetch("details.product","id")
+      .order().asc("id").findList();
+
+    Order order = orders.get(0);
+
+    JsonWriteOptions options = JsonWriteOptions.parsePath("*,details(id,orderQty,product(id))");
+
+    String jsonOrder = jsonContext.toJson(order, options);
+
+    Order o2 = jsonContext.toBean(Order.class, jsonOrder);
+    Customer customer = o2.getCustomer();
+
+    BeanDescriptor<Customer> custDesc = server.getBeanDescriptor(Customer.class);
+
+    Assert.assertTrue(custDesc.isReference(((EntityBean) customer)._ebean_getIntercept()));
+
+
+  }
+
+}

src/test/java/org/tests/text/json/TestTextJsonSimple.java

@@ -0,0 +1,148 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.text.PathProperties;
+import io.ebean.text.json.JsonContext;
+import io.ebean.text.json.JsonReadBeanVisitor;
+import io.ebean.text.json.JsonReadOptions;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestTextJsonSimple extends BaseTestCase {
+
+  class CustJsonRead implements JsonReadBeanVisitor<Customer> {
+
+    Customer bean;
+    Map<String, Object> unmapped;
+
+    @Override
+    public void visit(Customer bean, Map<String, Object> unmapped) {
+      this.bean = bean;
+      this.unmapped = unmapped;
+    }
+  }
+
+  class ContactJsonRead implements JsonReadBeanVisitor<Contact> {
+
+    Contact bean;
+    Map<String, Object> unmapped;
+
+    @Override
+    public void visit(Contact bean, Map<String, Object> unmapped) {
+      this.bean = bean;
+      this.unmapped = unmapped;
+    }
+  }
+
+  class AddressJsonRead implements JsonReadBeanVisitor<Address> {
+
+    Address bean;
+    Map<String, Object> unmapped;
+
+    @Override
+    public void visit(Address bean, Map<String, Object> unmapped) {
+      this.bean = bean;
+      this.unmapped = unmapped;
+    }
+  }
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name, status, shippingAddress")
+      .fetch("billingAddress", "line1, city").fetch("billingAddress.country", "*")
+      .fetch("contacts", "firstName,email")
+      .order().desc("id").findList();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    JsonContext json = server.json();
+
+    String jsonOutput = json.toJson(list);
+
+    // check that transient fields are included by default in the JSON output
+    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+
+    List<Customer> mList = json.toList(Customer.class, jsonOutput);
+    assertEquals(list.size(), mList.size());
+
+    CustJsonRead custJsonRead = new CustJsonRead();
+    ContactJsonRead contactJsonRead = new ContactJsonRead();
+    AddressJsonRead addressJsonRead = new AddressJsonRead();
+
+    JsonReadOptions options = new JsonReadOptions();
+    options.addRootVisitor(custJsonRead);
+    options.addVisitor("contacts", contactJsonRead);
+    options.addVisitor("billingAddress", addressJsonRead);
+
+    List<Customer> customers = json.toList(Customer.class, jsonOutput, options);
+
+    assertEquals(list.size(), customers.size());
+
+  }
+
+  @Test
+  public void testTransientIncludedByDefault() {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name")
+      .order().desc("id").findList();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    JsonContext json = server.json();
+
+    // not using pathProperties - includes transient fields by default
+    String jsonOutput = json.toJson(list);
+
+    // check that transient fields are included by default in the JSON output
+    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+
+    List<Customer> mList = json.toList(Customer.class, jsonOutput);
+    assertEquals(list.size(), mList.size());
+  }
+
+  @Test
+  public void testTransientIncludedExplicitly() {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .select("id, name")
+      .order().desc("id").findList();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    JsonContext json = server.json();
+
+    PathProperties pathProperties = PathProperties.parse("(id,name,selected)");
+    String jsonOutput = json.toJson(list, pathProperties);
+
+    // check that transient fields are included by explicit pathProperties
+    Assert.assertTrue(jsonOutput.contains("\"selected\":"));
+
+    pathProperties = PathProperties.parse("(id,name)");
+    jsonOutput = json.toJson(list, pathProperties);
+
+    // check that transient fields are NOT included when explicitly excluded by pathProperties
+    Assert.assertFalse(jsonOutput.contains("\"selected\":"));
+  }
+
+}

src/test/java/org/tests/text/json/TestTextJsonSuperSimple.java

@@ -0,0 +1,38 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonSuperSimple extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    List<Customer> list = Ebean.find(Customer.class).select("id, name").order().desc("id")
+      .findList();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    JsonContext json = server.json();
+
+    if (list.size() > 1) {
+      Customer customer = list.get(0);
+
+      String s = json.toJson(customer);
+      int statusPos = s.indexOf("status");
+      Assert.assertEquals(-1, statusPos);
+    }
+
+  }
+}

src/test/java/org/tests/text/json/TestTextJsonUpdateCascade.java

@@ -0,0 +1,99 @@
+package org.tests.text.json;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.text.json.JsonContext;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.Product;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+public class TestTextJsonUpdateCascade extends BaseTestCase {
+
+  @Test
+  public void test() throws IOException {
+
+    ResetBasicData.reset();
+
+    Customer c0 = ResetBasicData.createCustAndOrder("Test Json");
+
+    Customer c2 = Ebean.getReference(Customer.class, c0.getId());
+    List<Order> orders = c2.getOrders();
+
+    Assert.assertEquals(1, orders.size());
+
+    Order order = orders.get(0);
+    int size = order.getDetails().size();
+
+    Assert.assertTrue(size >= 3);
+
+    Customer cref = Ebean.getReference(Customer.class, c0.getId());
+    order.setCustomer(cref);
+    order.setStatus(Status.SHIPPED);
+
+    OrderDetail orderDetail0 = order.getDetails().get(0);
+    orderDetail0.setShipQty(300);
+    orderDetail0.setUnitPrice(56.98d);
+
+    // remove one of the details...
+    OrderDetail removedDetail = order.getDetails().remove(2);
+    Assert.assertNotNull(removedDetail);
+
+    Product p = Ebean.getReference(Product.class, 1);
+    OrderDetail newDetail = new OrderDetail(p, 899, 12.12d);
+    // newDetail.setOrder(order);
+    order.addDetail(newDetail);
+
+    EbeanServer server = Ebean.getServer(null);
+
+    JsonContext jsonContext = server.json();
+    String jsonString = jsonContext.toJson(order);
+
+    Order updOrder = jsonContext.toBean(Order.class, jsonString);
+
+    server.update(updOrder);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("rolej1");
+    Ebean.save(r1);
+
+    MRole r2 = new MRole();
+    r2.setRoleName("rolej2");
+    Ebean.save(r2);
+
+    MRole r3 = new MRole();
+    r3.setRoleName("rolej3");
+    Ebean.save(r3);
+
+    MUser u0 = new MUser();
+    u0.setUserName("userj1");
+    u0.addRole(r1);
+    u0.addRole(r2);
+    u0.addRole(r3);
+
+    Ebean.save(u0);
+
+    jsonContext.toJson(u0);
+
+    String s = "{\"userid\":" + u0.getUserid()
+      + ",\"userName\":\"userj1\", \"roles\":[{\"roleid\":" + r2.getRoleid() + "},{\"roleid\":"
+      + r3.getRoleid() + "}]} ";
+
+    MUser updMUser = jsonContext.toBean(MUser.class, s);
+
+    server.update(updMUser);
+
+    // checked transaction log to confirm correct behaviour
+  }
+
+}