Модульное тестирование JPA … Прекратите интеграционное тестирование!

Я хочу начать с простого вопроса.

«Как вы тестируете свои классы JPA?»

Теперь, прежде чем ответить, внимательно посмотрите на вопрос. Ключевые слова — юнит тест . Не тест, а юнит тест .

По моему опыту, после того, как задать этот вопрос, разговор идет примерно так.

«Как вы тестируете свои доменные объекты JPA?»

«Мы разработали этот общий проект, который запускает базу данных Derby в памяти и автоматически запускает сценарии в вашем проекте для создания базы данных и вставки данных для тестов».

«Где этот общий проект?»

«Это в Nexus. Мы включаем его как зависимость Maven».

«Я вижу это в POM. Вы знаете, что эта зависимость не имеет <scope> test </ scope>»

«А?»

«Не бери в голову. Где исходный код проекта?»

«Человек, который сделал это, здесь больше не работает, поэтому мы не знаем, где находится исходный код. Но нам не пришлось его менять».

«Где документация?»

«Хмм … мы просто копируем материал из существующих проектов и меняем DDL и запросы»

«Почему вы запускаете Derby для модульного теста? Модульные тесты должны быть простыми в обслуживании и быстрыми для запуска. Вы не можете запускать какие-либо фреймворки, такие как JPA, или полагаться на внешние ресурсы, такие как база данных. Они делают модульные тесты сложными и медленными. Бег.»

«Ну, классы используют JPA, вам нужна база данных для их проверки».

«Нет, не нужно. Вам не нужно запускать базу данных. JPA в значительной степени опирается на аннотации. Все, что вам нужно сделать, это убедиться, что все классы, поля и получатели правильно аннотированы. Так что просто тестируйте аннотации и значения их свойств «.

«Но это не скажет вам, работает ли он с базой данных».

«Итак? Вы должны писать простые и быстрые модульные тесты! Не интеграционные тесты! Для модульного теста все, что вам нужно знать, это то, правильно ли аннотированы классы JPA. Если они аннотированы правильно, они будут работать».

«Но что, если базы данных изменятся?»

«Хороший вопрос, но не для модульного теста. Для модульного теста все, что вам нужно знать, это то, что то, что работало раньше, все еще работает должным образом. Для сред, таких как JPA, которые зависят от аннотаций, чтобы работать должным образом, ваши модульные тесты должны убедиться, что аннотации не были перепутаны «.

«Но как вы узнаете, правильны ли аннотации? Вы должны запустить базу данных, чтобы получить их правильно».

«Ну, а если бы вы не использовали JPA, а что, если бы вы писали SQL вручную? Вы бы написали модульный тест для подключения к базе данных и продолжали возиться с SQL в своем коде, пока не поняли его правильно? Конечно нет. Это было бы безумием! Вместо этого вы должны использовать такой инструмент, как SQL Developer, подключиться к базе данных и работать над запросом до тех пор, пока он не будет работать правильно. Затем, после того, как вы получите правильный запрос, вы скопируйте и вставьте запрос в свой код. Вы знаете, что запрос работает — вы только что запустили его в SQL Developer — поэтому вам вообще не нужно подключаться к базе данных из вашего модульного теста. Ваш модульный тест должен только утверждать, что код генерирует запрос правильно. Если вы используете JPA, это в основном то же самое. Разница в том, что с JPA вы должны получить правильные аннотации. Итак, JPA работает где-то еще,затем, когда вы получите это правильно, скопируйте и вставьте его в свой проект и протестируйте аннотации ».

«Но где вы делаете эту работу? Может ли SQL Developer помочь выяснить аннотации JPA? …. Подождите! Я думаю, что Жаба может. У нас есть больше лицензий для этого?»

«Тьфу! Нет! Вы создаете исследовательский проект JPA, который запускает реализацию JPA, чтобы вы могли поиграться с аннотациями JPA. В этом исследовательском проекте в идеале вы должны подключиться к реальной базе данных разработки проекта, но вы можете подключиться к любому База данных, которая содержит данные, которые вам нужны. Выполнение всей этой работы в исследовательском проекте на самом деле намного лучше для реального проекта, потому что вы избавляетесь от базы данных в памяти от реального проекта, а также избавляетесь от попыток воспроизвести реальный проект. база данных в дерби.

«Где мы можем получить такой исследовательский проект?»

«Хм, вы просто создаете его; щелкните правой кнопкой мыши -> Создать -> Новый проект».

«Вы имеете в виду, что каждый должен создать свой собственный исследовательский проект? Похоже на пустую трата времени».

«Тьфу!»

Если у вас был подобный разговор, пожалуйста, дайте мне знать. Я хотел бы услышать ваши истории.

Но с учетом всего сказанного, как вы тестируете аннотации ваших объектов JPA. Ну, это не так уж сложно. API отражения Java предоставляют доступ к аннотациям классов. Итак, давайте посмотрим, как это может выглядеть.

Предположим, листинг 1 является объектом Person. Этот объект Person является частью вашей доменной модели и настроен для обработки JPA для сохранения данных в базе данных.

Листинг 1. Объектная модель Person и Phone

package org.thoth.jpa.UnitTesting;

import java.util.ArrayList;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * @author Michael Remijan [email protected] @mjremijan
 */
@Entity
@Table(name = "T_PERSON")
  public class Person {

  private Long id;
  private String firstName;
  private String lastName;
  private List<Phone> phones = new ArrayList<>();

  @Id
  @GeneratedValue()
  public Long getId() {
    return id;
  }

  public void setId(Long id) {
    this.id = id;
  }

  @Column(name = "FIRST_NAME")
  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  @Column(name = "LAST_NAME")
  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @OneToMany(mappedBy = "person", fetch = FetchType.LAZY)
  public List<Phone> getPhones() {
    return phones;
  }
}

package org.thoth.jpa.UnitTesting;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.junit.Assert;
import org.junit.Test;

/**
 * @author Michael Remijan [email protected] @mjremijan
 */
public class PersonTest {
  @Test
  public void typeAnnotations() {
    // assert
    AssertAnnotations.assertType(
        Person.class, Entity.class, Table.class);
  }


  @Test
  public void fieldAnnotations() {
    // assert
    AssertAnnotations.assertField(Person.class, "id");
    AssertAnnotations.assertField(Person.class, "firstName");
    AssertAnnotations.assertField(Person.class, "lastName");
    AssertAnnotations.assertField(Person.class, "phones");
  }


  @Test
  public void methodAnnotations() {
    // assert
    AssertAnnotations.assertMethod(
        Person.class, "getId", Id.class, GeneratedValue.class);

    AssertAnnotations.assertMethod(
        Person.class, "getFirstName", Column.class);

    AssertAnnotations.assertMethod(
        Person.class, "getLastName", Column.class);

    AssertAnnotations.assertMethod(
        Person.class, "getPhones", OneToMany.class);
  }


  @Test
  public void entity() {
    // setup
    Entity a
    = ReflectTool.getClassAnnotation(Person.class, Entity.class);

    // assert
    Assert.assertEquals("", a.name());
  }


  @Test
  public void table() {
    // setup
    Table t
    = ReflectTool.getClassAnnotation(Person.class, Table.class);

    // assert
    Assert.assertEquals("T_PERSON", t.name());
  }


  @Test
  public void id() {
    // setup
    GeneratedValue a
    = ReflectTool.getMethodAnnotation(
        Person.class, "getId", GeneratedValue.class);

    // assert
    Assert.assertEquals("", a.generator());
    Assert.assertEquals(GenerationType.AUTO, a.strategy());
  }


  @Test
  public void firstName() {
    // setup
    Column c
    = ReflectTool.getMethodAnnotation(
        Person.class, "getFirstName", Column.class);

    // assert
    Assert.assertEquals("FIRST_NAME", c.name());
  }


  @Test
  public void lastName() {
    // setup
    Column c
    = ReflectTool.getMethodAnnotation(
        Person.class, "getLastName", Column.class);

    // assert
    Assert.assertEquals("LAST_NAME", c.name());
  }


  @Test
  public void phones() {
    // setup
    OneToMany a
    = ReflectTool.getMethodAnnotation(
        Person.class, "getPhones", OneToMany.class);

    // assert
    Assert.assertEquals("person", a.mappedBy());
    Assert.assertEquals(FetchType.LAZY, a.fetch());
  }
}

package org.thoth.jpa.UnitTesting;

import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.List;

/**
 * @author Michael Remijan [email protected] @mjremijan
 */
public class AssertAnnotations {
  private static void assertAnnotations(
      List<Class> annotationClasses, List<Annotation> annotations) {
    // length
    if (annotationClasses.size() != annotations.size()) {
      throw new AssertionError(
        String.format("Expected %d annotations, but found %d"
          , annotationClasses.size(), annotations.size()
      ));
    }

    // exists
    annotationClasses.forEach(
      ac -> {
        long cnt
          = annotations.stream()
            .filter(a -> a.annotationType().isAssignableFrom(ac))
            .count();
        if (cnt == 0) {
          throw new AssertionError(
            String.format("No annotation of type %s found", ac.getName())
          );
        }
      }
    );
  }


  public static void assertType(Class c, Class... annotationClasses) {
    assertAnnotations(
        Arrays.asList(annotationClasses)
      , Arrays.asList(c.getAnnotations())
    );
  }


  public static void assertField(
      Class c, String fieldName, Class... annotationClasses) {
    try {
      assertAnnotations(
        Arrays.asList(annotationClasses)
        , Arrays.asList(c.getDeclaredField(fieldName).getAnnotations())
      );
    } catch (NoSuchFieldException nsfe) {
      throw new AssertionError(nsfe);
    }
  }


  public static void assertMethod(
      Class c, String getterName, Class...annotationClasses) {
    try {
      assertAnnotations(
        Arrays.asList(annotationClasses)
        , Arrays.asList(c.getDeclaredMethod(getterName).getAnnotations())
      );
    } catch (NoSuchMethodException nsfe) {
      throw new AssertionError(nsfe);
    }
  }
}

package org.thoth.jpa.UnitTesting;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author Michael Remijan [email protected] @mjremijan
 */
public class ReflectTool {
  public static <T extends Annotation> T getMethodAnnotation(
      Class<?> c, String methodName, Class<T> annotation) {
    try {
      Method m = c.getDeclaredMethod(methodName);
      return (T)m.getAnnotation(annotation);
    } catch (NoSuchMethodException nsme) {
      throw new RuntimeException(nsme);
    }
  }

  public static <T extends Annotation> T getFieldAnnotation(
      Class<?> c, String fieldName, Class<T> annotation) {
    try {
      Field f = c.getDeclaredField(fieldName);
      return (T)f.getAnnotation(annotation);
    } catch (NoSuchFieldException nsme) {
      throw new RuntimeException(nsme);
    }
  }

  public static <T extends Annotation> T getClassAnnotation(
      Class<?> c, Class<T> annotation) {
    return (T) c.getAnnotation(annotation);
  }
}