How to use

yawp

method

in

io.yawp.repository.query.DatastoreQueryTest

@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 testWhereInWithNullList() {
  saveManyBasicObjects(1);
  List<BasicObject> objects = yawp(BasicObject.class).where("intValue", "in", null).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());
}

@Test
public void testWhere() {
  saveManyBasicObjects(3);
  yawp.save(new BasicObject("different"));
  List<BasicObject> objects = yawp(BasicObject.class).where("stringValue", "=", "xpto").list();
  assertEquals(3, objects.size());
  assertEquals(1, objects.get(0).getIntValue());
  assertEquals(2, objects.get(1).getIntValue());
  assertEquals(3, objects.get(2).getIntValue());
}

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

@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 testCursor() {
  saveManyBasicObjects(3);
  QueryBuilder<BasicObject> q = yawp(BasicObject.class).order("intValue", "desc").limit(1);
  List<BasicObject> objects1 = q.list();
  assertEquals(3, objects1.get(0).getIntValue());
  List<BasicObject> objects2 = q.list();
  assertEquals(2, objects2.get(0).getIntValue());
  List<BasicObject> objects3 = yawp(BasicObject.class).cursor(q.getCursor()).order("intValue", "desc").limit(1).list();
  assertEquals(1, objects3.get(0).getIntValue());
}

@Test
public void testFindByIdUsingWhereIn() {
  BasicObject object1 = new BasicObject("xpto1");
  yawp.save(object1);
  BasicObject object2 = new BasicObject("xpto2");
  yawp.save(object2);
  final List<IdRef<BasicObject>> ids = Arrays.asList(object1.getId(), object2.getId());
  List<BasicObject> objects = yawp(BasicObject.class).where("id", "in", ids).order("stringValue").list();
  assertEquals(2, objects.size());
  assertEquals("xpto1", objects.get(0).getStringValue());
  assertEquals("xpto2", objects.get(1).getStringValue());
}

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

@Test
public void testOrderWithUnicode() {
  yawp.save(new BasicObject("\u00e1"));
  yawp.save(new BasicObject("\u00e9"));
  yawp.save(new BasicObject("\u00ed"));
  List<BasicObject> objects = yawp(BasicObject.class).order("stringValue", "desc").list();
  assertEquals(3, objects.size());
  assertEquals("\u00ed", objects.get(0).getStringValue());
  assertEquals("\u00e9", objects.get(1).getStringValue());
  assertEquals("\u00e1", objects.get(2).getStringValue());
}

@Test
public void testWhereWithComplexAndOrStructure() {
  saveManyBasicObjects(3);
  List<BasicObject> objects1 = yawp(BasicObject.class).where(
      or(and(c("intValue", "=", 1), c("intValue", "=", 2)), and(c("intValue", "=", 3), c("intValue", "=", 3)))).list();
  assertEquals(1, objects1.size());
  assertEquals(3, objects1.get(0).getIntValue());
  BaseCondition condition = or(and(c("intValue", "=", 3), c("intValue", "=", 3)), and(c("intValue", "=", 1), c("intValue", "=", 2)));
  List<BasicObject> objects2 = yawp(BasicObject.class).where(condition).list();
  assertEquals(1, objects2.size());
  assertEquals(3, objects2.get(0).getIntValue());
}

@Test
public void testFindByIdUsingWhere() {
  BasicObject object = new BasicObject("xpto");
  yawp.save(object);
  BasicObject retrievedObject = yawp(BasicObject.class).where("id", "=", object.getId()).first();
  assertEquals("xpto", retrievedObject.getStringValue());
}

@Test
public void testWithIdAsString() {
  BasicObject myObj = new BasicObject("xpto");
  yawp.save(myObj);
  BasicObject fetch = yawp(BasicObject.class).where("id", "=", myObj.getId().toString()).only();
  assertEquals("xpto", fetch.getStringValue());
}

@Test
public void testWithEnumAsString() {
  BasicObject running = new BasicObject("i'm running");
  running.setStatus(Status.RUNNING);
  yawp.save(running);
  BasicObject stopped = new BasicObject("i'm stopped");
  stopped.setStatus(Status.STOPPED);
  yawp.save(stopped);
  BasicObject obj = yawp(BasicObject.class).where("status", "=", "STOPPED").only();
  assertEquals("i'm stopped", obj.getStringValue());
}

@Test
public void testQueryRef() {
  BasicObject ref1 = new BasicObject("right");
  BasicObject ref2 = new BasicObject("wrong");
  yawp.save(ref1);
  yawp.save(ref2);
  yawp.save(new BasicObject("a", ref1.getId()));
  yawp.save(new BasicObject("b", ref2.getId()));
  BasicObject object = yawp(BasicObject.class).where("objectId->stringValue", "=", "right").only();
  assertEquals("a", object.getStringValue());
}