예제 #1
0
 @Test
 public void testFillResult() {
   data.delete(Person.class).get();
   Person person = randomPerson();
   data.insert(person);
   assertEquals(1, data.select(Person.class).get().collect(new HashSet<Person>()).size());
 }
예제 #2
0
 @Test
 public void testQueryCompoundConditions() {
   Person person = randomPerson();
   person.setAge(75);
   data.insert(person);
   Person p = data.select(Person.class).where(Person.AGE.gte(75)).get().first();
 }
예제 #3
0
 @Test
 public void testUpdateNoChanges() {
   Person person = randomPerson();
   data.insert(person);
   assertTrue(person.getId() > 0);
   data.update(person);
 }
예제 #4
0
 @Test
 public void testDeleteManyToMany() {
   final Person person = randomPerson();
   data.insert(person);
   final Collection<Group> groups = new ArrayList<>();
   data.runInTransaction(
       new Callable<Object>() {
         @Override
         public Object call() throws Exception {
           for (int i = 0; i < 10; i++) {
             Group group = new Group();
             group.setName("DeleteGroup" + i);
             data.insert(group);
             person.getGroups().add(group);
             groups.add(group);
           }
           data.update(person);
           return null;
         }
       });
   for (Group g : groups) {
     person.getGroups().remove(g);
   }
   data.update(person);
 }
예제 #5
0
 @Test
 public void testListResult() {
   data.delete(Person.class).get();
   Person person = randomPerson();
   data.insert(person);
   assertEquals(1, data.select(Person.class).get().toList().size());
 }
예제 #6
0
 @Test
 public void testUpdate() {
   Person person = randomPerson();
   data.insert(person);
   assertTrue(person.getId() > 0);
   person.setName("Bob Smith");
   Calendar calendar = Calendar.getInstance();
   calendar.set(1983, Calendar.NOVEMBER, 11);
   person.setBirthday(calendar.getTime());
   EntityProxy<Person> proxy = Person.$TYPE.proxyProvider().apply(person);
   int count = 0;
   for (Property ignored :
       proxy.filterProperties(
           new Predicate<Property<Person, ?>>() {
             @Override
             public boolean test(Property value) {
               return value.state() == PropertyState.MODIFIED;
             }
           })) {
     count++;
   }
   assertEquals(2, count);
   data.update(person);
   for (Property ignored :
       proxy.filterProperties(
           new Predicate<Property<Person, ?>>() {
             @Override
             public boolean test(Property value) {
               return value.state() == PropertyState.MODIFIED;
             }
           })) {
     fail();
   }
 }
예제 #7
0
 @Test
 public void testQueryNotNull() {
   for (int i = 0; i < 10; i++) {
     Person person = randomPerson();
     data.insert(person);
   }
   assertNotNull(data.select(Person.class).where(Person.NAME.notNull()).get().first());
 }
예제 #8
0
 @Test
 public void testInsert() {
   Person person = randomPerson();
   data.insert(person);
   assertTrue(person.getId() > 0);
   Person cached = data.select(Person.class).where(Person.ID.equal(person.getId())).get().first();
   assertSame(cached, person);
 }
예제 #9
0
 @Test
 public void testQueryBetween() {
   Person person = randomPerson();
   person.setAge(75);
   data.insert(person);
   Person p = data.select(Person.class).where(Person.AGE.between(50, 100)).get().first();
   assertTrue(p == person);
 }
예제 #10
0
 @Test
 public void testFindByKey() {
   Person person = randomPerson();
   data.insert(person);
   assertTrue(person.getId() > 0);
   Person other = data.findByKey(Person.class, person.getId());
   assertSame(person, other);
 }
예제 #11
0
 @Test
 public void testSingleQueryExecute() {
   data.insert(randomPersons(10));
   Result<Person> result = data.select(Person.class).get();
   assertEquals(10, result.toList().size());
   Person person = randomPerson();
   data.insert(person);
   assertEquals(11, result.toList().size());
 }
예제 #12
0
 @Test
 public void testUpdateOneToOneCascade() {
   Address address = randomAddress();
   Person person = randomPerson();
   data.insert(person);
   person.setAddress(address);
   data.update(person);
   assertSame(address.getPerson(), person);
 }
예제 #13
0
 @Test
 public void testQuerySelectTrim() {
   // TODO fix use ltrim/rtrim for SQLServer
   Person person = randomPerson();
   person.setName("  Name  ");
   data.insert(person);
   Tuple result = data.select(Person.NAME.trim().as("name")).get().first();
   String name = result.get(0);
   assertEquals(name, "Name");
 }
예제 #14
0
 @Test
 public void testDeleteOne() {
   Person person = randomPerson();
   data.insert(person);
   assertTrue(person.getId() > 0);
   data.delete(person);
   Person cached =
       data.select(Person.class).where(Person.ID.equal(person.getId())).get().firstOrNull();
   assertNull(cached);
 }
예제 #15
0
 @Test
 public void testDeleteCascadeOneToOne() {
   Address address = randomAddress();
   data.insert(address);
   assertTrue(address.getId() > 0);
   Person person = randomPerson();
   data.insert(person);
   data.delete(person);
   assertNull(address.getPerson());
 }
예제 #16
0
 @Test
 public void testRefreshAttributes() {
   Person person = randomPerson();
   data.insert(person);
   Phone phone = randomPhone();
   person.getPhoneNumbers().add(phone);
   data.update(person);
   data.refresh(person, Person.NAME, Person.PHONE_NUMBERS_SET, Person.ADDRESS, Person.EMAIL);
   assertTrue(person.getPhoneNumbersSet().contains(phone));
 }
예제 #17
0
 @Test
 public void testRefreshAll() {
   Person person = randomPerson();
   data.insert(person);
   Phone phone = randomPhone();
   person.getPhoneNumbers().add(phone);
   data.update(person);
   data.refreshAll(person);
   assertTrue(person.getPhoneNumbersSet().contains(phone));
 }
예제 #18
0
 @Test
 public void testQuerySelectWhereIn() {
   final String name = "Hello!";
   Person person = randomPerson();
   person.setName(name);
   data.insert(person);
   Group group = new Group();
   group.setName("Hello!");
   data.insert(group);
   person.getGroups().add(group);
   data.update(person);
   Return<Result<Tuple>> groupNames = data.select(Group.NAME).where(Group.NAME.equal(name));
   Person p = data.select(Person.class).where(Person.NAME.in(groupNames)).get().first();
   assertEquals(p.getName(), name);
   p = data.select(Person.class).where(Person.NAME.notIn(groupNames)).get().firstOrNull();
   assertNull(p);
   p =
       data.select(Person.class)
           .where(Person.NAME.in(Arrays.asList("Hello!", "Other")))
           .get()
           .first();
   assertEquals(p.getName(), name);
   p =
       data.select(Person.class)
           .where(Person.NAME.in(Collections.singleton("Hello!")))
           .get()
           .first();
   assertEquals(p.getName(), name);
   assertTrue(
       data.select(Person.class)
           .where(Person.NAME.notIn(Collections.singleton("Hello!")))
           .get()
           .toList()
           .isEmpty());
 }
예제 #19
0
 @Test(expected = PersistenceException.class)
 public void testViolateUniqueConstraint() {
   UUID uuid = UUID.randomUUID();
   Person p1 = randomPerson();
   p1.setUUID(uuid);
   data.insert(p1);
   Person p2 = randomPerson();
   p2.setUUID(uuid);
   data.insert(p2);
   fail();
 }
예제 #20
0
 @Test
 public void testQuerySelectDistinct() {
   for (int i = 0; i < 10; i++) {
     Person person = randomPerson();
     person.setName(String.valueOf(i / 2));
     data.insert(person);
   }
   try (Result<Tuple> result = data.select(Person.NAME).distinct().get()) {
     assertEquals(5, result.toList().size());
   }
 }
예제 #21
0
 @Test
 public void testDeleteAll() {
   final String name = "someName";
   for (int i = 0; i < 10; i++) {
     Person person = randomPerson();
     person.setName(name);
     data.insert(person);
   }
   assertTrue(data.delete(Person.class).get().value() > 0);
   assertTrue(data.select(Person.class).get().toList().isEmpty());
 }
예제 #22
0
 @Test
 public void testQueryOrderBy() {
   for (int i = 0; i < 5; i++) {
     Person person = randomPerson();
     person.setAge(i);
     data.insert(person);
   }
   try (Result<Tuple> query = data.select(Person.AGE).orderBy(Person.AGE.desc()).get()) {
     Integer i = query.first().get(0);
     assertTrue(i.equals(4));
   }
 }
예제 #23
0
 @Test
 public void testInsertOneToManyInverseThroughSet() {
   Person person = randomPerson();
   data.insert(person);
   Phone phone1 = randomPhone();
   Phone phone2 = randomPhone();
   person.getPhoneNumbers().add(phone1);
   person.getPhoneNumbers().add(phone2);
   data.update(person);
   assertEquals(2, person.getPhoneNumbersSet().size());
   assertTrue(person.getPhoneNumbersSet().containsAll(Arrays.asList(phone1, phone2)));
 }
예제 #24
0
 @Test
 public void testQuerySelectCountWhere() {
   for (int i = 0; i < 10; i++) {
     Person person = randomPerson();
     if (i == 0) {
       person.setName("countme");
     }
     data.insert(person);
   }
   assertEquals(
       1, data.count(Person.class).where(Person.NAME.eq("countme")).get().value().intValue());
 }
예제 #25
0
 @Test
 public void testDeleteBatch() {
   List<Person> persons = new ArrayList<>();
   for (int i = 0; i < 100; i++) {
     Person person = randomPerson();
     persons.add(person);
   }
   data.insert(persons);
   assertEquals(100, data.count(Person.class).get().value().intValue());
   data.delete(persons);
   assertEquals(0, data.count(Person.class).get().value().intValue());
 }
예제 #26
0
 @Test
 public void testInsertOneToManyOneInsert() {
   Person person = randomPerson();
   Phone phone1 = randomPhone();
   Phone phone2 = randomPhone();
   person.getPhoneNumbers().add(phone1);
   person.getPhoneNumbers().add(phone2);
   data.insert(person);
   data.refresh(person, Person.PHONE_NUMBERS);
   HashSet<Phone> set = new HashSet<>(person.getPhoneNumbers().toList());
   assertEquals(2, set.size());
   assertTrue(set.containsAll(Arrays.asList(phone1, phone2)));
 }
예제 #27
0
 @Test
 public void testVersionIncrement() {
   Group group = new Group();
   group.setName("group");
   group.setType(GroupType.PRIVATE);
   data.insert(group);
   // Assert.assertTrue(group.version() == 1);
   group.setType(GroupType.PUBLIC);
   data.update(group);
   data.refresh(group, Group.VERSION);
   // System.out.println("group.version + " + group.version());
   assertTrue(group.getVersion() > 0);
 }
예제 #28
0
 @Test
 public void testDeleteCascadeOneToMany() {
   Person person = randomPerson();
   data.insert(person);
   Phone phone1 = randomPhone();
   phone1.setOwner(person);
   data.insert(phone1);
   int phoneId = phone1.getId();
   person.getPhoneNumbers();
   data.delete(person);
   Phone phone = data.select(Phone.class).where(Phone.ID.equal(phoneId)).get().firstOrNull();
   assertNull(phone);
 }
예제 #29
0
 @Test
 public void testSingleQueryWhere() {
   final String name = "duplicateFirstName";
   data.delete(Person.class).where(Person.NAME.equal(name)).get();
   for (int i = 0; i < 10; i++) {
     Person person = randomPerson();
     person.setName(name);
     data.insert(person);
   }
   try (Result<Person> query = data.select(Person.class).where(Person.NAME.equal(name)).get()) {
     assertEquals(10, query.toList().size());
   }
 }
예제 #30
0
 @Test
 public void testSingleQueryWhereNull() {
   data.delete(Person.class).where(Person.NAME.isNull()).get();
   Person person = randomPerson();
   person.setName(null);
   data.insert(person);
   try (Result<Person> query = data.select(Person.class).where(Person.NAME.equal(null)).get()) {
     assertEquals(1, query.toList().size());
   }
   try (Result<Person> query = data.select(Person.class).where(Person.NAME.isNull()).get()) {
     assertEquals(1, query.toList().size());
   }
 }