ALGUEM SABE COMO FAÇO PARA TESTAR EJB?

DAO GENERICO

package br.com.sistemaagropecuaria.sessionBean;

import br.com.sistemaagropecuaria.sessionBean.interfaces.DaoSession;

import java.lang.reflect.ParameterizedType;

import java.util.List;

import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

public class DaoSessionBean<T, ID> implements DaoSession<T, ID> {

    private EntityManager entityManager;
    private final Class<T> persistentClass;

    public DaoSessionBean() {
        this.persistentClass =
                (Class<T>) (((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
    }

    private Class<T> getPersistenceClass() {
        return persistentClass;
    }

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    protected EntityManager getEntityManager() {
        if (entityManager == null) {
            throw new IllegalStateException("Erro");
        }
        return entityManager;
    }

    @Override
    public T create(T entity) {
        getEntityManager().clear();
        getEntityManager().persist(entity);
            return entity;
    }

    @Override
    public T update(T entity) {
        getEntityManager().merge(entity);
        return entity;
    }

    @Override
    public void delete(T entity) {
        entity = getEntityManager().merge(entity);
        getEntityManager().remove(entity);
    }

    @Override
    public boolean exists(int id) {
        if (this.getById(id) != null) {
            return true;
        }
        return false;
    }

    @Override
    public List<T> getAll() {
        String sql = "SELECT object(o) FROM " + persistentClass.getSimpleName() + " as o ";
        try {
            return getEntityManager().createQuery(sql).getResultList();
        } catch (NoResultException e) {
            System.out.println("Nenhum Retorno");
            return null;
        }

    }

    @SuppressWarnings("unchecked")
    public List<T> listPesqParam(String query, Map<String, Object> params) {
        Query q = getEntityManager().createQuery(query);
        for (String chave : params.keySet()) {
            q.setParameter(chave, params.get(chave));

        }
        return q.getResultList();
    }

    @SuppressWarnings("unchecked")
    public List<T> listPesqParam(String query, Map<String, Object> params,
            int maximo, int atual) {
        Query q = getEntityManager().
                createQuery(query).
                setMaxResults(maximo).
                setFirstResult(atual);

        for (String chave : params.keySet()) {
            q.setParameter(chave, params.get(chave));

        }
        return q.getResultList();
    }

    @Override
    public T getById(int id) {
        try {
            T entity = (T) getEntityManager().find(getPersistenceClass(), id);
            return entity;
        } catch (NoResultException e) {
            System.out.println("Nenhum Retorno");
            return null;
        }
    }

    @Override
    public Query pesq(String query) {
        try {
            return getEntityManager().createQuery(query);
        } catch (NoResultException e) {
            System.out.println("Nenhum Retorno");

            return null;
        }
    }

     @Override
    public Query pesqSql(String query) {
        try {
            return getEntityManager().createNativeQuery(query);
        } catch (NoResultException e) {
            System.out.println("Nenhum Retorno");

            return null;
        }
    }

    @SuppressWarnings("unchecked")
    public List<T> listPesq(String query) {
        Query q = getEntityManager().createQuery(query);
        return q.getResultList();
    }

    @SuppressWarnings("unchecked")
    public T pesqParam(String query, Map<String, Object> params) {
        Query q = getEntityManager().createQuery(query);
        for (String chave : params.keySet()) {
            q.setParameter(chave, params.get(chave));
        }
        try {
            return (T) q.getSingleResult();
        } catch (NoResultException nre) {
            return null;
        }
    }

}


-------------------------------------------------------------------------------------
Classe que quero testar


package br.com.sistemaagropecuaria.sessionBean;


import br.com.sistemaagropecuaria.entity.TipoLocais;
import br.com.sistemaagropecuaria.sessionBean.interfaces.TipoLocaisSessionLocal;
import br.com.sistemaagropecuaria.sessionBean.interfaces.TipoLocaisSessionRemote;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.ejb.TransactionManagement;
import javax.ejb.TransactionManagementType;
import javax.persistence.Query;


@Stateless
@TransactionManagement(TransactionManagementType.CONTAINER)
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public class TipoLocaisSessionBean extends DaoSessionBean<TipoLocais,Long> implements TipoLocaisSessionLocal,TipoLocaisSessionRemote {

       //Encontrar TipoLocais por descricao
     public TipoLocais getTipoLocaisByDescricao(String tipoLocaisDescricao) {
        Query qry = pesq("Select obj1 FROM TipoLocais obj1 WHERE obj1.descricao = ?1");
        qry.setParameter(1,tipoLocaisDescricao);
        TipoLocais tipoLocaisEncontrado = null;
         try{
              tipoLocaisEncontrado =  (TipoLocais) qry.getSingleResult();
             } catch (Exception e){
            System.out.println("No result"+e.getMessage());
            System.out.println("ERROR");

        }
        return tipoLocaisEncontrado;
     }

}



-----------------------------------------------------------------------------
Interface da classe

package br.com.sistemaagropecuaria.sessionBean.interfaces;

import br.com.sistemaagropecuaria.entity.TipoLocais;
import javax.ejb.Local;


@Local
public interface TipoLocaisSessionLocal extends DaoSession<TipoLocais,Long> {

    public TipoLocais getTipoLocaisByDescricao(String tipoLocaisDescricao);

}


----------------------------------------------------------------------------

Classe que testa mas não funciona

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.sistemaagropecuaria.errado;

import br.com.sistemaagropecuaria.entity.TipoLocais;
import br.com.sistemaagropecuaria.sessionBean.interfaces.TipoLocaisSessionLocal;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

public class TipoLocaisSessionBeanTestaaaaaaaaaaaa {

    private TipoLocaisSessionLocal tipoLocaisSessionLocal;
    private Integer id = 1;

    public void setTipoLocaisSessionLocal(TipoLocaisSessionLocal tipoLocaisSessionLocal) {
        this.tipoLocaisSessionLocal = tipoLocaisSessionLocal;
    }

    private TipoLocais getTipoLocais() {
        TipoLocais tipoLocais = new TipoLocais();
        tipoLocais.setDescricao("Teste");
        return tipoLocais;
    }

    @Test
    public void testSalvar() {
        TipoLocais tipoLocais = null;
        tipoLocais = tipoLocaisSessionLocal.update(getTipoLocais());
        assertNotNull(tipoLocais);
        assertEquals(id, tipoLocais.getIdTipoLocais());
        assertEquals("Teste", tipoLocais.getDescricao());
    }

    @Test
    public void testAtualizar() {
        TipoLocais tipoLocais = tipoLocaisSessionLocal.getById(id);
        tipoLocais.setDescricao("Teste 2");
        tipoLocais = tipoLocaisSessionLocal.update(getTipoLocais());
        assertNotNull(tipoLocais);
        assertEquals("Teste 2", tipoLocais.getDescricao());
    }

    @Test
    public void testTodos() {
        List<TipoLocais> tipoLocais = tipoLocaisSessionLocal.getAll();
        assertNotNull(tipoLocais);
        assertEquals(1, tipoLocais.size());
        assertEquals("Teste 2", tipoLocais.get(0).getDescricao());

    }

    @Test
    public void testListPesqParam() {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("id", id);
        List<TipoLocais> tipoLocais =
                tipoLocaisSessionLocal.listPesqParam("SELECT tl FROM TipoLocais tl WHERE tl.idTipoLocais=:id", params);
        assertNotNull(tipoLocais);
        assertEquals(1, tipoLocais.size());
        assertEquals("Teste 2", tipoLocais.get(0).getDescricao());

    }

    @Test
    public void testPesqParam() {
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("id", id);
        TipoLocais tipoLocais =
                tipoLocaisSessionLocal.pesqParam("SELECT tl FROM TipoLocais tl WHERE p.idTipoLocais=:id", params);
        assertNotNull(tipoLocais);
        assertEquals("Teste 2", tipoLocais.getDescricao());

    }

    @Test
    public void testExcluir() {
        TipoLocais tipoLocais = tipoLocaisSessionLocal.getById(id);
        tipoLocaisSessionLocal.delete(tipoLocais);
        assertNull(tipoLocaisSessionLocal.getById(id));
    }
}


-------------------------------------------------------------------------------