Refine search
/** * Test having with entity. */ private void testHavingWithEntity() { String queryString = "Select p from Person p where p.age < 40 group by p.age having max(p.salary) > 600"; Query query = em.createQuery(queryString); List resultList = query.getResultList(); Assert.assertEquals(1, resultList.size()); Person person = (Person) (resultList.get(0)); Assert.assertEquals("7", person.getPersonId()); Assert.assertEquals("KPM", person.getPersonName()); Assert.assertEquals(30, person.getAge().intValue()); Assert.assertEquals(700.0, person.getSalary()); }
@Test public void testOnUpdate() { Person p1 = new Person(); p1.setPersonName("vivek"); p1.setAge(32); p1.setDay(Day.TUESDAY); p1.setPersonId("p1"); p1.setSalary(6000.345); em.persist(p1); em.clear(); Person p = em.find(Person.class, "p1"); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName()); p.setAge(12); p.setPersonName("newvivek"); em.merge(p); em.clear(); Query findQuery = em.createQuery("Select p from Person p WHERE p.personName = vivek"); List<Person> allPersons = findQuery.getResultList(); Assert.assertEquals(0, allPersons.size()); findQuery = em.createQuery("Select p from Person p WHERE p.personName = newvivek"); allPersons = findQuery.getResultList(); Assert.assertEquals(new Integer(12), allPersons.get(0).getAge()); em.remove(em.find(Person.class, "p1")); }
/** * Assert person. * * @param actual * the actual * @param person * the person */ private void assertPerson(Object actual, Person person) { Person actualPerson = (Person) actual; Assert.assertEquals(actualPerson.getPersonId(), person.getPersonId()); Assert.assertEquals(actualPerson.getPersonName(), person.getPersonName()); Assert.assertEquals(actualPerson.getAge().intValue(), person.getAge().intValue()); Assert.assertEquals(actualPerson.getSalary(), person.getSalary()); Assert.assertEquals(actualPerson.getDay(), person.getDay()); }
private Person prepareData(String rowKey, int age) { Person o = new Person(); o.setPersonId(rowKey); o.setPersonName("vivek"); o.setAge(age); o.setDay(Day.THURSDAY); return o; }
/** * Creates the person. * * @param id * the id * @param age * the age * @param name * the name * @param salary * the salary */ private void createPerson(String id, int age, String name, Double salary) { person = new Person(); person.setAge(age); // person.setDay(Day.FRIDAY); person.setPersonId(id); person.setPersonName(name); person.setSalary(salary); em.persist(person); }
Object p3 = prepareData("3", 15); Query findQuery = em.createQuery("Select p from Person p", Person.class); List<Person> allPersons = findQuery.getResultList(); Assert.assertTrue(allPersons.isEmpty()); findQuery = em.createQuery("Select p from Person p where p.personName = vivek"); allPersons = findQuery.getResultList(); Assert.assertTrue(allPersons.isEmpty()); em.persist(p1); allPersons = findQuery.getResultList(); Assert.assertEquals(2, allPersons.size()); Assert.assertEquals(new Integer(10), allPersons.get(0).getAge()); Assert.assertEquals(new Integer(20), allPersons.get(1).getAge()); Person personWithKey = new Person(); personWithKey.setPersonId("111"); em.persist(personWithKey); Person p = findById(Person.class, "1", em); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName()); Assert.assertEquals(Day.THURSDAY, p.getDay()); em.clear();
Person p1 = new Person(); p1.setAge(32); p1.setDay(Day.TUESDAY); p1.setPersonId("p1"); p1.setSalary(6000.345); p1.setPersonName("vivek"); em.persist(p1); em.clear(); Person p2 = new Person(); p2.setAge(24); p2.setDay(Day.MONDAY); p2.setPersonId("p2"); p2.setSalary(8000.345); p2.setPersonName("vivek"); em.persist(p2); Person p3 = new Person(); p3.setAge(24); p3.setDay(Day.MONDAY); p3.setPersonId("p3"); p3.setSalary(8000.345); p3.setPersonName("vivek"); Person p = new Person(); p.setAge(20); p.setDay(Day.MONDAY); p.setPersonId("p4"); p.setPersonName("pragalbh garg");
Person p1 = new Person(); p1.setAge(32); p1.setDay(Day.TUESDAY); p1.setPersonId("p1"); p1.setSalary(6000.345); em.persist(p1); em.clear(); Person p2 = new Person(); p2.setAge(24); p2.setDay(Day.MONDAY); p2.setPersonId("p2"); p2.setSalary(8000.345); em.persist(p2); allPersons = findQuery.getResultList(); Assert.assertEquals(new Integer(32), allPersons.get(0).getAge()); Assert.assertEquals(new Integer(32), allPersons.get(0).getAge()); Assert.assertEquals("p2", allPersons.get(0).getPersonId()); Assert.assertEquals(new Integer(24), allPersons.get(0).getAge()); Assert.assertEquals("p1", allPersons.get(0).getPersonId()); Assert.assertEquals(new Integer(32), allPersons.get(0).getAge());
em.persist(p1); em.persist(p2); Assert.assertNotNull(p); em.persist(p3); ((Person) p2).setPersonName("rollback"); em.merge(p2); em.merge(null); Assert.assertNull(p); Assert.assertNull(p); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName());
em1.getTransaction().begin(); Object p1 = prepareData("11", 10); em1.persist(p1); em1.getTransaction().commit(); em2.getTransaction().begin(); Person found = em2.find(Person.class, "11"); found.setPersonName("merged"); em2.merge(found); found = em3.find(Person.class, "11"); found.setPersonName("lastemerge"); try Person finalFound = em2.find(Person.class, "11"); Assert.assertNotNull(finalFound); Assert.assertEquals("merged", finalFound.getPersonName());
@Test public void testDeletion() throws Exception { Object p1 = prepareData("1", 10); Object p2 = prepareData("2", 20); Object p3 = prepareData("3", 15); em.persist(p1); em.persist(p2); em.persist(p3); Person p = findById(Person.class, "1", em); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName()); em.remove(p); em.clear(); TypedQuery<Person> query = em.createQuery("Select p from Person p", Person.class); List<Person> results = query.getResultList(); Assert.assertNotNull(query); Assert.assertNotNull(results); }
@Test public void test() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException Person p1 = new Person(); p1.setAge(98); p1.setPersonId("1"); p1.setDay(Day.SATURDAY); p1.setSalary(6000.345); em.persist(p1); Person p2 = new Person(); p2.setAge(100); p2.setPersonId("2"); p2.setDay(Day.SATURDAY); p2.setSalary(10000.345); em.persist(p2); List<Person> results = queryObj.getResultList(); Assert.assertEquals(1,results.size()); Assert.assertNotNull(KunderaCoreUtils.getLuceneQueryFromJPAQuery(kunderaQuery,kunderaMetadata)); //assert on lucene query transformation. Assert.assertNotNull(queryObj.populateUsingLucene()); //assert on lucene query transformation. em.clear();
@Test public void invalidValidQueryTest() { LuceneIndexer indexer = LuceneIndexer.getInstance(LUCENE_DIR_PATH); EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata( ((EntityManagerFactoryImpl) emf).getKunderaMetadataInstance(), Person.class); Person p = new Person(); p.setAge(32); p.setDay(Day.TUESDAY); p.setPersonId("p1"); indexer.index(metadata, (MetamodelImpl) ((EntityManagerFactoryImpl) emf).getKunderaMetadataInstance() .getApplicationMetadata().getMetamodel("patest"), p); indexer.flush(); Assert.assertNotNull(indexer); String luceneQuery = "+Person.AGE:32 AND +entity.class:com.impetus.kundera.query.Person"; try { Map<String, Object> results = indexer.search(luceneQuery, 0, 10, false, ((EntityManagerFactoryImpl) emf).getKunderaMetadataInstance(), metadata); Assert.assertTrue(!results.isEmpty()); } catch (LuceneIndexingException liex) { Assert.fail(); } indexer.close(); }
@Test public void testCommit() { em.getTransaction().begin(); Object p1 = prepareData("1", 10); Object p2 = prepareData("2", 20); Object p3 = prepareData("3", 15); em.persist(p1); em.persist(p2); em.persist(p3); // on commit. em.getTransaction().commit(); Person p = findById(Person.class, "1", em); Assert.assertNotNull(p); em.getTransaction().begin(); ((Person) p2).setPersonName("rollback"); em.merge(p2); // roll back, should roll back person name for p2! em.getTransaction().rollback(); p = findById(Person.class, "1", em); Assert.assertNotNull(p); p = findById(Person.class, "2", em); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName()); Assert.assertNotSame("rollback", p.getPersonName()); }
/** * Test order by ascending. */ private void testOrderByAscending() { String queryString = "Select p.personName from Person p order by p.age ASC"; Query query = em.createQuery(queryString); List resultList = query.getResultList(); Assert.assertEquals(4, resultList.size()); Assert.assertEquals("pragalbh", ((Person) resultList.get(0)).getPersonName()); Assert.assertEquals("dev", ((Person) resultList.get(1)).getPersonName()); Assert.assertEquals("karthik", ((Person) resultList.get(2)).getPersonName()); Assert.assertEquals("amit", ((Person) resultList.get(3)).getPersonName()); }
/** * Test parameter query. */ private void testParameterQuery() { String queryString = "Select p from Person p where p.personName = :personName"; Query query = em.createQuery(queryString); query.setParameter("personName", "amit"); List resultList = query.getResultList(); Assert.assertEquals(1, resultList.size()); Assert.assertEquals(100.0, ((Person) resultList.get(0)).getSalary()); }
@Test public void testUpdation() throws Exception { Object p1 = prepareData("1", 10); Object p2 = prepareData("2", 20); Object p3 = prepareData("3", 15); em.persist(p1); em.persist(p2); em.persist(p3); em.clear(); Person p = findById(Person.class, "1", em); Assert.assertNotNull(p); Assert.assertEquals("vivek", p.getPersonName()); // modify record. p.setPersonName("newvivek"); em.merge(p); assertUpdation(em, "Person", Person.class, "vivek", "newvivek", "personName"); }
@Test public void test() Person p = new Person(); // create object. p.setAge(23); p.setPersonId("personId"); Assert.assertTrue(manager.isCacheEmpty()); Assert.assertTrue(manager.getElementCollectionCache().isEmpty()); Assert.assertNull(manager.getElementCollectionObjectName("personId", p)); Assert.assertEquals(-1, manager.getLastElementCollectionObjectCount("personId"));
@Test public void testGetIdentifier() { PersistenceUnitUtil utils = emf.getPersistenceUnitUtil(); Person p = new Person(); p.setAge(32); p.setPersonId("1"); Assert.assertNotNull(utils.getIdentifier(p)); Assert.assertEquals("1",utils.getIdentifier(p)); }
@Test public void testIsLoadedWithoutReference() { PersistenceUnitUtil utils = emf.getPersistenceUnitUtil(); Person p = new Person(); p.setAge(32); p.setPersonId("1"); Assert.assertNotNull(utils); Assert.assertTrue(utils.isLoaded(p, "personId")); Assert.assertFalse(utils.isLoaded(null, "personName")); }