#919 - io.ebean package initial

src/test/java/io/ebeaninternal/server/query/DefaultSqlRowTest.java

@@ -0,0 +1,22 @@
+package io.ebeaninternal.server.query;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DefaultSqlRowTest {
+
+  @Test
+  public void test_keyConversion() {
+
+    DefaultSqlRow row = new DefaultSqlRow(16, 0.5f, "T");
+    row.put("Foo", "hello");
+
+    assertThat(row.containsKey("foo")).isTrue();
+    assertThat(row.getString("foo")).isEqualTo("hello");
+    assertThat(row.get("foo")).isEqualTo("hello");
+
+    row.remove("foo");
+    assertThat(row.isEmpty()).isTrue();
+  }
+}

src/test/java/io/ebeaninternal/server/query/LimitOffsetPagedListTest.java

@@ -0,0 +1,105 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebeaninternal.api.SpiQuery;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LimitOffsetPagedListTest {
+
+  private EbeanServer server = Ebean.getDefaultServer();
+
+  @Test
+  public void getPageIndex_when_firstRowsZero() throws Exception {
+    assertEquals(limit(0, 10).getPageIndex(), 0);
+  }
+
+  @Test
+  public void getPageIndex_when_10_10() {
+    assertEquals(limit(10, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_20_10() {
+    assertEquals(limit(20, 10).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_1_10() throws Exception {
+    assertEquals(limit(1, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_9_10() throws Exception {
+    assertEquals(limit(1, 10).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_10_4() {
+    assertEquals(limit(10, 4).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_10_5() {
+    assertEquals(limit(10, 5).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_10_9() {
+    assertEquals(limit(10, 9).getPageIndex(), 2);
+  }
+
+  @Test
+  public void getPageIndex_when_10_11() {
+    assertEquals(limit(10, 11).getPageIndex(), 1);
+  }
+
+  @Test
+  public void getPageIndex_when_21_10() {
+    assertEquals(limit(21, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_29_10() {
+    assertEquals(limit(29, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_30_10() {
+    assertEquals(limit(30, 10).getPageIndex(), 3);
+  }
+
+  @Test
+  public void getPageIndex_when_31_10() {
+    assertEquals(limit(31, 10).getPageIndex(), 4);
+  }
+
+  @Test
+  public void getPageIndex_when_40_10() {
+    assertEquals(limit(40, 10).getPageIndex(), 4);
+  }
+
+
+  private LimitOffsetPagedList<Order> limit(int first, int max) {
+    return limitQuery(queryWith(first, max));
+  }
+
+  private LimitOffsetPagedList<Order> limitQuery(SpiQuery<Order> query) {
+    return new LimitOffsetPagedList<>(server, query);
+  }
+
+  private SpiQuery<Order> queryWith(int first, int max) {
+    SpiQuery<Order> query = query();
+    query.setFirstRow(first);
+    query.setMaxRows(max);
+    return query;
+  }
+
+  private SpiQuery<Order> query() {
+    return (SpiQuery<Order>) server.find(Order.class);
+  }
+
+}

src/test/java/io/ebeaninternal/server/query/OrderVersionDescTest.java

@@ -0,0 +1,81 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.Version;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class OrderVersionDescTest {
+
+  private final long now = System.currentTimeMillis();
+
+  @Test
+  public void sort() {
+
+    Version<?> atNull = atNull();
+    Version<?> at100 = at(100);
+    Version<?> at200 = at(200);
+    Version<?> at300 = at(300);
+
+    List<Version<?>> versions = new ArrayList<>();
+    versions.add(at200);
+    versions.add(atNull);
+    versions.add(at300);
+    versions.add(at100);
+
+    Collections.sort(versions, OrderVersionDesc.INSTANCE);
+
+    assertThat(versions.get(0)).isSameAs(at300);
+    assertThat(versions.get(1)).isSameAs(at200);
+    assertThat(versions.get(2)).isSameAs(at100);
+    assertThat(versions.get(3)).isSameAs(atNull);
+  }
+
+  @Test
+  public void compare_lt() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(0), at(1)), 1);
+  }
+
+  @Test
+  public void compare_gt() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(2), at(1)), -1);
+  }
+
+  @Test
+  public void compare_eq() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(1), at(1)), 0);
+  }
+
+  @Test
+  public void compare_nullFirst() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(atNull(), at(1)), 1);
+  }
+
+
+  @Test
+  public void compare_nullLast() {
+
+    assertEquals(OrderVersionDesc.INSTANCE.compare(at(0), atNull()), -1);
+  }
+
+  private Version<?> atNull() {
+    return new Version();
+  }
+
+  private Version at(long diff) {
+    Timestamp timestamp = new Timestamp(now + diff);
+    Version ver = new Version();
+    ver.setStart(timestamp);
+    return ver;
+  }
+}

src/test/java/io/ebeaninternal/server/query/RawSqlQueryPlanKeyTest.java

@@ -0,0 +1,61 @@
+package io.ebeaninternal.server.query;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RawSqlQueryPlanKeyTest {
+
+
+  @Test
+  public void test_equals_same_instance() {
+
+    RawSqlQueryPlanKey key = key("select foo", true, true, "");
+    assertThat(key).isEqualTo(key);
+    assertThat(key.hashCode()).isEqualTo(key.hashCode());
+  }
+
+  @Test
+  public void test_equals_diff_instance() {
+
+    assertThat(key("select foo", true, true, "")).isEqualTo(key("select foo", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isEqualTo(key("select foo", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_sql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select bar", true, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select bar", true, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rawSqlFlag() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", false, true, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", false, true, "").hashCode());
+  }
+
+  @Test
+  public void test_notEquals_diff_rowNumberIncluded() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, false, ""));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, false, "").hashCode());
+  }
+
+
+  @Test
+  public void test_notEquals_diff_logWhereSql() {
+
+    assertThat(key("select foo", true, true, "")).isNotEqualTo(key("select foo", true, true, "a"));
+    assertThat(key("select foo", true, true, "").hashCode()).isNotEqualTo(key("select foo", true, true, "a").hashCode());
+  }
+
+  @NotNull
+  private RawSqlQueryPlanKey key(String sql, boolean rawSql, boolean rowNumberIncluded, String logWhereSql) {
+    return new RawSqlQueryPlanKey(sql, rawSql, rowNumberIncluded, logWhereSql);
+  }
+
+}

src/test/java/io/ebeaninternal/server/query/SplitNameTest.java

@@ -0,0 +1,83 @@
+package io.ebeaninternal.server.query;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class SplitNameTest {
+
+  @Test
+  public void add() throws Exception {
+
+    assertEquals(SplitName.add("a", "b"), "a.b");
+    assertEquals(SplitName.add("a", "b.c"), "a.b.c");
+  }
+
+  @Test
+  public void count() throws Exception {
+
+    assertEquals(SplitName.count("a"), 0);
+    assertEquals(SplitName.count("a.b"), 1);
+    assertEquals(SplitName.count("a.b.c"), 2);
+    assertEquals(SplitName.count("a.b.c.foo"), 3);
+  }
+
+  @Test
+  public void parent() throws Exception {
+    assertNull(SplitName.parent("a"));
+    assertEquals(SplitName.parent("a.b"), "a");
+    assertEquals(SplitName.parent("a.b.c"), "a.b");
+    assertNull(SplitName.parent(null));
+  }
+
+  @Test
+  public void split() throws Exception {
+
+    String[] split = SplitName.split("a.b.c");
+    assertEquals(split[0], "a.b");
+    assertEquals(split[1], "c");
+  }
+
+  @Test
+  public void begin_when_one() throws Exception {
+
+    assertEquals(SplitName.begin("a"), "a");
+  }
+
+  @Test
+  public void begin_when_both() throws Exception {
+
+    assertEquals(SplitName.begin("a.b"), "a");
+  }
+
+  @Test
+  public void begin_when_multi() throws Exception {
+
+    assertEquals(SplitName.begin("a.b.c"), "a");
+  }
+
+  @Test
+  public void splitBegin_when_both() throws Exception {
+
+    String[] split = SplitName.splitBegin("a.b");
+    assertEquals(split[0], "a");
+    assertEquals(split[1], "b");
+  }
+
+  @Test
+  public void splitBegin_when_bothPlus() throws Exception {
+
+    String[] split = SplitName.splitBegin("a.b.c");
+    assertEquals(split[0], "a");
+    assertEquals(split[1], "b.c");
+  }
+
+  @Test
+  public void splitBegin_when_one() throws Exception {
+
+    String[] split = SplitName.splitBegin("a");
+    assertEquals(split[0], "a");
+    assertNull(split[1]);
+  }
+}

src/test/java/io/ebeaninternal/server/query/TestFutureRowCountErrorHandling.java

@@ -0,0 +1,101 @@
+package io.ebeaninternal.server.query;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.FutureIds;
+import io.ebean.FutureList;
+import io.ebean.FutureRowCount;
+import io.ebean.Query;
+import io.ebean.Transaction;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+
+public class TestFutureRowCountErrorHandling extends BaseTestCase {
+
+  @Test
+  public void testFutureRowCount() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureRowCount<Customer> futureRowCount = server.findFutureCount(query, null);
+
+    QueryFutureRowCount<Customer> internalRowCount = (QueryFutureRowCount<Customer>) futureRowCount;
+    Transaction t = internalRowCount.getTransaction();
+
+    try {
+      futureRowCount.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+
+  @Test
+  public void testFutureIds() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureIds<Customer> futureIds = server.findFutureIds(query, null);
+
+    QueryFutureIds<Customer> internalFuture = (QueryFutureIds<Customer>) futureIds;
+    Transaction t = internalFuture.getTransaction();
+
+    try {
+      internalFuture.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+
+
+  @Test
+  public void testFutureList() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    EbeanServer server = Ebean.getServer(null);
+
+    Query<Customer> query = server.createQuery(Customer.class)
+      .where().eq("doesNotExist", "this will fail")
+      .query();
+
+    FutureList<Customer> futureList = server.findFutureList(query, null);
+
+    QueryFutureList<Customer> internalFuture = (QueryFutureList<Customer>) futureList;
+    Transaction t = internalFuture.getTransaction();
+
+    try {
+      internalFuture.get();
+      Assert.assertTrue("never get here as the SQL is invalid", false);
+
+    } catch (ExecutionException e) {
+      // Confirm the Transaction has been rolled back
+      Assert.assertFalse("Underlying transaction was rolled back cleanly", t.isActive());
+    }
+
+  }
+}