How to use

DatastoreQueryTest

in

io.yawp.repository.query

@Test
public void testWhereWithoutIndexWithId() {
  yawp.save(setId(new BasicObject("a", 1l), 1l));
  yawp.save(setId(new BasicObject("b", 2l), 2l));
  yawp.save(setId(new BasicObject("c", 3l), 3l));
  IdRef<BasicObject> id = IdRef.create(yawp, BasicObject.class, 1l);
  List<BasicObject> objects = yawp(BasicObject.class).where(c("id", "=", id).or(c("longValue", "=", 3l))).list();
  assertObjects(objects, "a", "c");
  objects = yawp(BasicObject.class).where(c("id", "=", id).and(c("longValue", "=", 1l))).list();
  assertObjects(objects, "a");
  objects = yawp(BasicObject.class).where(c("id", "=", id).and(c("longValue", "=", 3l))).list();
  assertObjects(objects);
}

@Test
public void testListOfIdsProperty() {
  BasicObject object = new BasicObject("xpto");
  object.setIdList(Arrays.asList(id(BasicObject.class, 10l), id(BasicObject.class, 20l)));
  yawp.save(object);
  BasicObject retrievedObject;
  retrievedObject = yawp(BasicObject.class).where("idList", "=", id(BasicObject.class, 10l)).first();
  assertEquals("xpto", retrievedObject.getStringValue());
  retrievedObject = yawp(BasicObject.class).where("idList", "<", id(BasicObject.class, 999l)).first();
  assertEquals("xpto", retrievedObject.getStringValue());
}

@Test
public void testWhereWithOr() {
  saveManyBasicObjects(2);
  List<BasicObject> objects = yawp(BasicObject.class).where(or(c("intValue", "=", 1), c("intValue", "=", 2))).list();
  assertEquals(2, objects.size());
  sort(objects);
  assertEquals(2, objects.size());
  assertEquals("xpto", objects.get(0).getStringValue());
  assertEquals(1, objects.get(0).getIntValue());
  assertEquals("xpto", objects.get(1).getStringValue());
  assertEquals(2, objects.get(1).getIntValue());
}

@Test
public void testWhereWithoutIndex() {
  yawp.save(new BasicObject("a", 1l));
  yawp.save(new BasicObject("b", 2l));
  List<BasicObject> objects = yawp(BasicObject.class).where("longValue", "=", 1l).list();
  assertObjects(objects, "a");
}

@SuppressWarnings("unchecked")
@Test
public void testToMap() {
  Map<String, Object> map = yawp(BasicObject.class).where("field", "=", "value").toMap();
  assertEquals("io.yawp.repository.models.basic.BasicObject", map.get("clazz"));
  assertEquals(Collections.emptyList(), map.get("preOrders"));
  assertEquals(Collections.emptyList(), map.get("postOrders"));
  Map<String, String> condition = (Map<String, String>) map.get("condition");
  assertEquals("field", condition.get("field"));
  assertEquals("EQUAL", condition.get("whereOperator"));
  assertEquals("value", condition.get("whereValue"));
}

@Test
public void testWhereInWithEmptyList() {
  saveManyBasicObjects(1);
  List<BasicObject> objects = yawp(BasicObject.class).where("intValue", "in", Collections.emptyList()).list();
  assertEquals(0, objects.size());
}

@Test
public void testWhereWithoutIndexAndCondition() {
  yawp.save(new BasicObject("a", 1l));
  yawp.save(new BasicObject("a", 2l));
  yawp.save(new BasicObject("b", 1l));
  List<BasicObject> objects = yawp(BasicObject.class).where(c("stringValue", "=", "a").and(c("longValue", "=", 1l))).list();
  assertObjects(objects, "a");
}

@Test(expected = RuntimeException.class)
public void testIdsWithPostFilter() {
  assertEquals(0, yawp(BasicObject.class).where("longValue", "=", 2l).ids().size());
}

@Test
public void testWhereWithoutIndexOrCondition() {
  yawp.save(new BasicObject("a", 1l));
  yawp.save(new BasicObject("b", 2l));
  yawp.save(new BasicObject("c", 1l));
  List<BasicObject> objects = yawp(BasicObject.class).where(c("stringValue", "=", "a").or(c("longValue", "=", 1l))).list();
  assertObjects(objects, "a", "c");
}

@Test
public void testWhereWithAndNot() {
  saveManyBasicObjects(5);
  List<BasicObject> objects = yawp(BasicObject.class).where(and(c("intValue", ">", 1), c("intValue", "<", 5)).not()).list();
  assertEquals(2, objects.size());
  sort(objects);
  assertEquals(1, objects.get(0).getIntValue());
  assertEquals(5, objects.get(1).getIntValue());
}

@Test(expected = RuntimeException.class)
public void testIdsWithPostOrder() {
  assertEquals(0, yawp(BasicObject.class).sort("longValue").ids().size());
}

@Test
public void testWhereWithoutIndexComplexConditions() {
  yawp.save(new BasicObject("a", 1l));
  yawp.save(new BasicObject("a", 2l));
  yawp.save(new BasicObject("c", 3l));
  yawp.save(new BasicObject("c", 4l));
  yawp.save(new BasicObject("d", 5l));
  yawp.save(new BasicObject("e", 6l));
  BaseCondition c2 = c("stringValue", "=", "c").and(c("longValue", "=", 3l));
  List<BasicObject> objects = yawp(BasicObject.class).where(c("stringValue", "=", "a").or(c2)).list();
  assertObjects(objects, "a", "a", "c");
}

@Test
public void testWhereInWithNullList() {
  saveManyBasicObjects(1);
  List<BasicObject> objects = yawp(BasicObject.class).where("intValue", "in", null).list();
  assertEquals(0, objects.size());
}

@Test
public void testWithEmptyIn() {
  BasicObject myObj1 = new BasicObject("xpto1");
  yawp.save(myObj1);
  List<BasicObject> objects = yawp(BasicObject.class).where("id", "in", Collections.emptyList()).list();
  assertEquals(0, objects.size());
}

@Test
public void testOnlyIdNoResult() {
  try {
    yawp(BasicObject.class).where("stringValue", "=", "xpto").onlyId();
  } catch (NoResultException ex) {
    return;
  }
  assertTrue(false);
}

@Test
public void testLimit() {
  saveManyBasicObjects(3);
  List<BasicObject> objects = yawp(BasicObject.class).order("intValue", "desc").limit(1).list();
  assertEquals(1, objects.size());
  assertEquals(3, objects.get(0).getIntValue());
}

@Test
public void testWhereInWithEmptyListOrTrueExpression() {
  saveManyBasicObjects(3);
  BaseCondition emptyListCondition = c("intValue", "in", Collections.emptyList());
  BaseCondition condition = or(emptyListCondition, c("stringValue", "=", "xpto"));
  List<BasicObject> objects = yawp(BasicObject.class).where(condition).list();
  assertEquals(3, objects.size());
}

@Test
public void testWhereInWithEmptyListAndFalseExpression() {
  saveManyBasicObjects(1);
  BaseCondition emptyListCondition = c("intValue", "in", Collections.emptyList());
  BaseCondition condition = and(emptyListCondition, c("stringValue", "=", "otpx"));
  List<BasicObject> objects = yawp(BasicObject.class).where(condition).list();
  assertEquals(0, objects.size());
}

@Test
public void testWhereWithUnicode() {
  yawp.save(new BasicObject("\u00c1"));
  List<BasicObject> objects = yawp(BasicObject.class).where("stringValue", "=", "\u00c1").list();
  assertEquals(1, objects.size());
  assertEquals("\u00c1", objects.get(0).getStringValue());
}

@Test
public void testQueryFromOptions() {
  saveManyBasicObjects(3);
  QueryOptions options = QueryOptions
      .parse("{where: ['stringValue', '=', 'xpto'], order: [{p: 'intValue', d: 'desc'}], limit: 2}");
  List<BasicObject> objects = yawp(BasicObject.class).options(options).list();
  assertEquals(2, objects.size());
  assertEquals(3, objects.get(0).getIntValue());
  assertEquals(2, objects.get(1).getIntValue());
}