/*******************************************************************************
* Copyright (c) 2005, 2015 SAP. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* SAP - initial API and implementation
******************************************************************************/
package org.eclipse.persistence.testing.tests.wdf.jpa1.query;
import java.util.Calendar;
import java.util.Date;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.Query;
import javax.persistence.TemporalType;
import org.eclipse.persistence.exceptions.DatabaseException;
import org.eclipse.persistence.exceptions.QueryException;
import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;
public abstract class QueryTest extends JPA1Base {
protected void assertInvalidQueryWithParameters(String queryString, Set<InputParameterHolder> parameters) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
executeQueryWithParameters(queryString, parameters, em);
message = "Failed to detect invalid query:'" + queryString + "'";
} catch (IllegalArgumentException IAex) {
isPassed = true;
message = IAex.getMessage();
}
verify(isPassed, message);
}
/**
* @param queryString
* @param parameters
* @param em
*/
private void executeQueryWithParameters(String queryString, Set<InputParameterHolder> parameters, EntityManager em) {
Query query = em.createQuery(queryString);
for (InputParameterHolder holder : parameters) {
setParameterHolder(query, holder);
}
}
/**
* @param query
* @param holder
*/
private void setParameterHolder(Query query, InputParameterHolder holder) {
if (holder.isTemporal()) {
if (holder.getType() == ParameterType.POSITIONAL) {
if (holder.getValue() instanceof Date) {
query.setParameter((Integer) holder.getIdentitfier(), (Date) holder.getValue(), holder.getTemporalType());
} else if (holder.getValue() instanceof Calendar) {
query.setParameter((Integer) holder.getIdentitfier(), (Calendar) holder.getValue(), holder
.getTemporalType());
}
} else if (holder.getType() == ParameterType.NAMED) {
if (holder.getValue() instanceof Date) {
query.setParameter((String) holder.getIdentitfier(), (Date) holder.getValue(), holder.getTemporalType());
} else if (holder.getValue() instanceof Calendar) {
query
.setParameter((String) holder.getIdentitfier(), (Calendar) holder.getValue(), holder
.getTemporalType());
}
}
} else {
if (holder.getType() == ParameterType.POSITIONAL) {
query.setParameter((Integer) holder.getIdentitfier(), holder.getValue());
} else if (holder.getType() == ParameterType.NAMED) {
query.setParameter((String) holder.getIdentitfier(), holder.getValue());
}
}
}
protected void assertValidQueryWithParameters(String queryString, Set<InputParameterHolder> parameters) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
executeQueryWithParameters(queryString, parameters, em);
message = "Test successfully passed.";
isPassed = true;
} catch (IllegalArgumentException IAex) {
message = IAex.getMessage();
}
verify(isPassed, message);
}
protected void assertParameterValid(Query query, InputParameterHolder holder) {
setParameterHolder(query, holder);
}
protected void assertParameterInvalid(Query query, InputParameterHolder holder) {
boolean passed = false;
try {
setParameterHolder(query, holder);
} catch (IllegalArgumentException e) {
passed = true;
}
verify(passed, ("missing IllegalArgumentException"));
}
protected void assertValidUpdateExecution(String queryString) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
getEnvironment().beginTransaction(em);
Query q = em.createQuery(queryString);
q.executeUpdate();
message = "Query '" + queryString + "' was successfully created.";
isPassed = true;
getEnvironment().commitTransactionAndClear(em);
} catch (Exception ex) {
getEnvironment().rollbackTransactionAndClear(em);
message = ex.getMessage();
}
verify(isPassed, message);
}
protected void assertInvalidUpdateExecution(String queryString) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
getEnvironment().beginTransaction(em);
Query q = em.createQuery(queryString);
q.executeUpdate();
message = "Failed to detect invalid query:'" + queryString + "'";
getEnvironment().commitTransactionAndClear(em);
} catch (Exception ex) {
isPassed = true;
message = ex.getMessage();
getEnvironment().rollbackTransactionAndClear(em);
}
verify(isPassed, message);
}
protected void assertValidQuery(String queryString) {
EntityManager em = getEnvironment().getEntityManager();
try {
em.createQuery(queryString);
} catch (RuntimeException e) {
throw new RuntimeException("An exception occurred while creating a query for String >>" + queryString + "<<", e);
}
}
protected void assertInvalidQuery(String queryString) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
Query query = em.createQuery(queryString);
try {
query.getResultList();
message = "Failed to detect invalid query:'" + queryString + "'";
} catch (PersistenceException ex) {
isPassed = true;
message = ex.getMessage();
} catch (DatabaseException ex) { // FIXME
isPassed = true;
message = ex.getMessage();
}
} catch (IllegalArgumentException IAex) {
isPassed = true;
message = IAex.getMessage();
} catch (QueryException ex) { // FIXME
isPassed = true;
message = ex.getMessage();
}
verify(isPassed, message);
}
protected void assertInvalidQueryExecution(String queryString) {
boolean isPassed = false;
String message;
EntityManager em = getEnvironment().getEntityManager();
try {
Query q = em.createQuery(queryString);
q.getResultList();
message = "Failed to detect invalid query:'" + queryString + "'";
} catch (Exception ex) {
isPassed = true;
message = ex.getMessage();
}
verify(isPassed, message);
}
protected void assertValidQueryExecution(String queryString) {
assertValidQueryExecutionWithArgs(queryString, new Object[0]);
}
private boolean isUtilDateLike(Object arg) {
return arg instanceof java.util.Date || arg instanceof java.util.Calendar;
}
protected void assertValidQueryExecutionWithArgs(String queryString, Object... args) {
EntityManager em = getEnvironment().getEntityManager();
Query q = em.createQuery(queryString);
// setting arguments
if (args != null && args.length > 0) {
for (int i = 0; i < args.length; i++) {
if (!isUtilDateLike(args[i])) {
q.setParameter(i + 1, args[i]);
} else {
throw new IllegalArgumentException(
"Currently, for this test-method the use of date-like input parameters is not supported");
}
}
}
q.getResultList();
}
protected enum ParameterType {
NAMED, POSITIONAL
}
protected class InputParameterHolder {
private boolean isTemporal = false;
private ParameterType type;
private final Object identitfier;
private final Object value;
private TemporalType temporalType;
public InputParameterHolder(Object identifier, Object value, TemporalType temporalType) {
this(identifier, value);
this.temporalType = temporalType;
isTemporal = true;
}
public InputParameterHolder(Object identifier, Object value) {
this.identitfier = identifier;
this.value = value;
if (identifier instanceof String) {
type = ParameterType.NAMED;
} else if (identifier instanceof Integer) {
type = ParameterType.POSITIONAL;
} else {
throw new IllegalArgumentException("InputParameterHolder was created with an illegal identifier: " + identifier
+ ". Only String and Integer are allowed.");
}
}
public Object getIdentitfier() {
return identitfier;
}
public Object getValue() {
return value;
}
public TemporalType getTemporalType() {
return temporalType;
}
public ParameterType getType() {
return type;
}
public boolean isTemporal() {
return isTemporal;
}
}
}