/*******************************************************************************
* * Copyright 2012 Impetus Infotech.
* *
* * Licensed under the Apache License, Version 2.0 (the "License");
* * you may not use this file except in compliance with the License.
* * You may obtain a copy of the License at
* *
* * http://www.apache.org/licenses/LICENSE-2.0
* *
* * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS,
* * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* * See the License for the specific language governing permissions and
* * limitations under the License.
******************************************************************************/
package com.impetus.client.crud;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.NoResultException;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.impetus.client.crud.entities.Day;
import com.impetus.client.crud.entities.PersonBatchMongoEntity;
import com.impetus.client.crud.entities.PersonMongo;
import com.impetus.client.crud.entities.PersonMongo.Month;
import com.impetus.client.utils.MongoUtils;
import com.impetus.kundera.client.Client;
public class PersonMongoTest extends BaseTest
{
private static final String _PU = "mongoTest";
/** The emf. */
private static EntityManagerFactory emf;
/** The em. */
private static EntityManager em;
private Map<Object, Object> col;
/**
* Sets the up.
*
* @throws Exception
* the exception
*/
@Before
public void setUp() throws Exception
{
emf = Persistence.createEntityManagerFactory(_PU);
em = emf.createEntityManager();
col = new java.util.HashMap<Object, Object>();
}
/**
* On insert mongo.
*/
@Test
public void onInsertMongo() throws Exception
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
Query findQuery = em.createQuery("Select p from PersonMongo p");
List<PersonMongo> allPersons = findQuery.getResultList();
Assert.assertNotNull(allPersons);
Assert.assertTrue(allPersons.isEmpty());
findQuery = em.createQuery("Select p from PersonMongo p where p.personName = vivek");
allPersons = findQuery.getResultList();
Assert.assertNotNull(allPersons);
Assert.assertTrue(allPersons.isEmpty());
em.persist(p1);
em.persist(p2);
em.persist(p3);
col.put("1", p1);
col.put("2", p2);
col.put("3", p3);
em.clear();
PersonMongo p = findById(PersonMongo.class, "1", em);
Assert.assertNotNull(p);
Assert.assertEquals(Day.FRIDAY, p.getDay());
Assert.assertEquals(Month.JAN, p.getMonth());
Assert.assertEquals("vivek", p.getPersonName());
Assert.assertNotNull(p.getMap());
Assert.assertFalse(p.getMap().isEmpty());
Assert.assertEquals(2, p.getMap().size());
assertFindByName(em, "PersonMongo", PersonMongo.class, "vivek", "personName");
assertFindByNameAndAge(em, "PersonMongo", PersonMongo.class, "vivek", "10", "personName");
assertFindByNameAndAgeGTAndLT(em, "PersonMongo", PersonMongo.class, "vivek", "10", "20", "personName");
assertFindByNameAndAgeBetween(em, "PersonMongo", PersonMongo.class, "vivek", "10", "15", "personName");
assertFindByRange(em, "PersonMongo", PersonMongo.class, "1", "2", "personId");
assertFindWithoutWhereClause(em, "PersonMongo", PersonMongo.class);
Query query = em.createNamedQuery("mongo.named.query");
query.setParameter("name", "vivek");
List<PersonMongo> results = query.getResultList();
Assert.assertEquals(3, results.size());
Assert.assertEquals(Month.JAN, results.get(0).getMonth());
query = em.createNamedQuery("mongo.position.query");
query.setParameter(1, "vivek");
results = query.getResultList();
Assert.assertEquals(3, results.size());
Assert.assertEquals(Month.JAN, results.get(0).getMonth());
findQuery = em.createQuery("Select p from PersonMongo p where p.day = :day");
findQuery.setParameter("day", Day.FRIDAY);
allPersons = findQuery.getResultList();
Assert.assertNotNull(allPersons);
Assert.assertEquals(3, allPersons.size());
query = em.createQuery("select p from PersonMongo p");
query.setMaxResults(2);
results = query.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(2, results.size());
Assert.assertEquals(Month.JAN, results.get(0).getMonth());
query = em.createQuery("select p from PersonMongo p");
query.setMaxResults(1);
PersonMongo result = (PersonMongo)(query.getSingleResult());
Assert.assertNotNull(result);
Assert.assertEquals(Month.JAN, result.getMonth());
query = em.createQuery("select p from PersonMongo p where p.personName = kuldeep");
try
{
result = (PersonMongo)(query.getSingleResult());
Assert.fail("Should have gone to catch block!");
} catch(NoResultException nrex)
{
Assert.assertNotNull(nrex.getMessage());
}
selectIdQuery();
onExecuteScript();
}
private void selectIdQuery()
{
String query = "select p.personId from PersonMongo p";
Query q = em.createQuery(query);
List<PersonMongo> results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(3, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNull(results.get(0).getPersonName());
Assert.assertNull(results.get(0).getAge());
query = "Select p.personId from PersonMongo p where p.personName = vivek";
// // find by name.
q = em.createQuery(query);
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertFalse(results.isEmpty());
Assert.assertEquals(3, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNull(results.get(0).getPersonName());
Assert.assertNull(results.get(0).getAge());
query = "Select p.personId from PersonMongo p where p.personName = vivek";
// // find by name.
q = em.createQuery(query);
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertFalse(results.isEmpty());
Assert.assertEquals(3, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNull(results.get(0).getPersonName());
Assert.assertNull(results.get(0).getAge());
q = em.createQuery("Select p.personId from PersonMongo p where p.personName = vivek and p.age > " + 10);
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertFalse(results.isEmpty());
Assert.assertEquals(2, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNull(results.get(0).getPersonName());
Assert.assertNull(results.get(0).getAge());
}
/**
* On typed named query.
*/
@Test
public void onNamedTypedQuery()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
TypedQuery<PersonMongo> query = em.createNamedQuery("mongo.named.query", PersonMongo.class);
query.setParameter("name", "vivek");
List<PersonMongo> results = query.getResultList();
Assert.assertEquals(3, results.size());
Assert.assertEquals(Month.JAN, results.get(0).getMonth());
}
/**
* On generic typed named query.
*/
@Test
public void onGenericTypedNamedQuery()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
TypedQuery<Object> query = em.createNamedQuery("mongo.named.query", Object.class);
query.setParameter("name", "vivek");
List<Object> results = query.getResultList();
Assert.assertEquals(3, results.size());
Assert.assertEquals(PersonMongo.class, results.get(0).getClass());
}
/**
* On invalid typed query.
*
*/
@Test
public void onInvalidTypedNamedQuery()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
TypedQuery<PersonBatchMongoEntity> query = null;
try
{
query = em.createNamedQuery("mongo.named.query", PersonBatchMongoEntity.class);
query.setParameter("name", "vivek");
Assert.fail("Should have gone to catch block, as it is an invalid scenario!");
}
catch (IllegalArgumentException iaex)
{
Assert.assertNull(query);
}
}
/**
* On merge mongo.
*/
@Test
public void onMergeMongo() throws Exception
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
col.put("1", p1);
col.put("2", p2);
col.put("3", p3);
PersonMongo p = findById(PersonMongo.class, "1", em);
Assert.assertNotNull(p);
Assert.assertEquals("vivek", p.getPersonName());
// modify record.
p.setPersonName("Mc.John Doe");
em.merge(p);
assertOnMerge(em, "PersonMongo", PersonMongo.class, "vivek", "Mc.John Doe", "personName");
}
/**
* Tear down.
*
* @throws Exception
* the exception
*/
@After
public void tearDown() throws Exception
{/*
* Delete is working, but as row keys are not deleted from cassandra, so
* resulting in issue while reading back. // Delete
* em.remove(em.find(Person.class, "1")); em.remove(em.find(Person.class,
* "2")); em.remove(em.find(Person.class, "3")); em.close(); emf.close();
* em = null; emf = null;
*/
for (Object val : col.values())
{
em.remove(val);
}
MongoUtils.dropDatabase(emf, _PU);
emf.close();
}
private void onExecuteScript()
{
Map<String, Client<Query>> clients = (Map<String, Client<Query>>) em.getDelegate();
Client client = clients.get(_PU);
String jScript = "db.system.js.save({ _id: \"echoFunction\",value : function(x) { return x; }})";
Object result = ( client).executeScript(jScript);
Assert.assertNull(result);
String findOneJScript = "db.PERSON.findOne()";
result = ( client).executeScript(findOneJScript);
Assert.assertNotNull(result);
String findAllJScript = "db.PERSON.find( { \"PERSON_NAME\" : \"vivek\" } )";
result = (client).executeScript(findAllJScript);
Assert.assertNotNull(result);
try
{
em.createNativeQuery(findAllJScript, PersonMongo.class).getResultList();
Assert.fail();
}
catch (Exception e)
{
Assert.assertEquals(
"java.lang.UnsupportedOperationException: Native query support is not enabled in mongoDB",
e.getMessage());
}
}
@Test
public void incrementFunctionTest()
{
Object p1 = prepareMongoInstance("1", 10);
em.persist(p1);
String updateFunc = "UPDATE PersonMongo set age = INCREMENT(1) where personId = :personId";
Query q = em.createQuery(updateFunc);
q.setParameter("personId", "1");
Assert.assertEquals(1, q.executeUpdate());
updateFunc = "UPDATE PersonMongo set age = DECREMENT(1) where personId = :personId";
q = em.createQuery(updateFunc);
q.setParameter("personId", "1");
Assert.assertEquals(1, q.executeUpdate());
updateFunc = "UPDATE PersonMongo set age = DECREMENT(2)";
q = em.createQuery(updateFunc);
Assert.assertEquals(1, q.executeUpdate());
em.clear();
String query = "Select p from PersonMongo p ";
q = em.createQuery(query);
List<PersonMongo> results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(new Integer(8), results.get(0).getAge());
updateFunc = "UPDATE PersonMongo set age = INCREMENT(5)";
q = em.createQuery(updateFunc);
Assert.assertEquals(1, q.executeUpdate());
em.clear();
query = "Select p from PersonMongo p ";
q = em.createQuery(query);
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(new Integer(13), results.get(0).getAge());
}
@Test
public void subQueryTest()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
String query = "Select p from PersonMongo p where p.personName <> :name and p.age NOT IN :ageList" +
" and (personId = :personId)";
Query q = em.createQuery(query);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(20);add(21);}});
q.setParameter("personId", "1");
List<PersonMongo> results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(0, results.size());
query = "Select p from PersonMongo p where (p.personName = :name and p.age NOT IN :ageList)" +
" and (personId = :personId)";
q = em.createQuery(query);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(20);add(21);}});
q.setParameter("personId", "1");
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(1, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNotNull(results.get(0).getPersonName());
Assert.assertNotNull(results.get(0).getAge());
}
@Test
public void interClauseOperatorTest()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
String query = "Select p from PersonMongo p where (p.personName = :name OR p.age NOT IN :ageList)" +
" AND (personId = :personId)";
Query q = em.createQuery(query);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(10);add(20);}});
q.setParameter("personId", "1");
List<PersonMongo> results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(0, results.size());
query = "Select p from PersonMongo p where (p.personName = :name AND p.age NOT IN :ageList)" +
" OR (personId = :personId)";
q = em.createQuery(query);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(10);add(21);}});
q.setParameter("personId", "1");
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(3, results.size());
query = "Select p from PersonMongo p where (p.personName = :name OR p.age NOT IN :ageList)" +
" OR (personId = :personId) ORDER BY p.age";
q = em.createQuery(query);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(10);add(21);}});
q.setParameter("personId", "1");
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(3, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNotNull(results.get(0).getPersonName());
Assert.assertNotNull(results.get(0).getAge());
Assert.assertEquals("1", results.get(0).getPersonId());
Assert.assertEquals("2", results.get(2).getPersonId());
}
@Test
public void paginationQueryTest()
{
Object p1 = prepareMongoInstance("1", 10);
Object p2 = prepareMongoInstance("2", 20);
Object p3 = prepareMongoInstance("3", 15);
em.persist(p1);
em.persist(p2);
em.persist(p3);
String query = "Select p from PersonMongo p ";
Query q = em.createQuery(query);
q.setFirstResult(1);
q.setMaxResults(3);
List<PersonMongo> results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(2, results.size());
query = "Select p from PersonMongo p where (p.personName = :name and p.age NOT IN :ageList)" +
" and (personId = :personId)";
q = em.createQuery(query);
q.setFirstResult(0);
q.setMaxResults(3);
q.setParameter("name", "vivek");
q.setParameter("ageList", new ArrayList<Integer>(){{add(20);add(21);}});
q.setParameter("personId", "1");
results = q.getResultList();
Assert.assertNotNull(results);
Assert.assertEquals(1, results.size());
Assert.assertNotNull(results.get(0).getPersonId());
Assert.assertNotNull(results.get(0).getPersonName());
Assert.assertNotNull(results.get(0).getAge());
}
}