CUBA 应用程序中的中间件集成测试

public class SampleIntegrationTest {

    @RegisterExtension (1)
    public static PetclinicTestContainer testContainer =
            PetclinicTestContainer.Common.INSTANCE; (2)

    @Test
    public void persistenceAPI_canBeRetrieved_fromTheTestContainer() {

        Persistence persistence = testContainer.persistence(); (3)

        assertNotNull(persistence);
    }
}

@Service(VisitService.NAME)
public class VisitServiceBean implements VisitService {
  @Inject
  protected DataManager dataManager;
  @Inject
  protected TimeSource timeSource;
  //...
  @Override
  public Visit createVisitForToday(String identificationNumber) {
    Optional<Pet> pet = loadPetByIdentificationNumber(identificationNumber);  (1)

    if (!pet.isPresent()) {
      return null;
    }

    return saveVisit( (2)
        createVisitForPet(pet.get())
    );
  }

  private Visit createVisitForPet(Pet pet) {
    Visit visit = dataManager.create(Visit.class);
    visit.setPet(pet);
    visit.setVisitDate(timeSource.currentTimestamp());
    return visit;
  }

  private Visit saveVisit(Visit visit) {
    return dataManager.commit(visit);
  }

  private Optional<Pet> loadPetByIdentificationNumber(String identificationNumber) {
    return dataManager.load(Pet.class)
        .query("e.identificationNumber = ?1", identificationNumber)
        .optional();
  }
  //...
}

public class VisitServiceTest {
    @RegisterExtension
    public static PetclinicTestContainer testContainer = PetclinicTestContainer.Common.INSTANCE;
    private static VisitService visitService; (1)
    private static PetclinicVisitDb db;

    private Visit visit;
    private Pet pikachu;

    @BeforeAll
    public static void setupEnvironment() {
        visitService = AppBeans.get(VisitService.class);

        db = new PetclinicVisitDb( (2)
            AppBeans.get(DataManager.class),
            testContainer
        );
    }

    @BeforeEach
    public void loadPikachu() { (3)
        pikachu = db.petWithName("Pikachu", "pet-with-owner-and-type");
    }

    // different test cases...

    @AfterEach
    public void cleanupVisit() { (4)
        db.remove(visit);
    }
}

public class PetclinicVisitDb {

  public Pet petWithName(String name, String view) { /* ... */ }

  public void remove(Entity<UUID> entity) { /* ... */ }

  public Optional<Pet> petWithIdentificationNumber(
          String identificationNumber
  ) { /* ... */ }

  public Long countVisitsFor(Pet pet) { /* ... */ }

  public Long countVisits() { /* ... */ }

}

class VisitServiceTest {
    // ...
    private Visit visit;
    private Pet pikachu;

    @BeforeEach
    public void loadPikachu() {
        pikachu = db.petWithName("Pikachu", "pet-with-owner-and-type");
    }

    @Test
    public void createVisitForToday_createsANewVisit_forTheCorrectPet() { (1)
        // given: there is one visit associated to pikachu
        assertThat(db.countVisitsFor(pikachu))
            .isEqualTo(1);
        // when: logic is executed for pikachus identification number
        visit = visitService.createVisitForToday(
                pikachu.getIdentificationNumber()
        );
        // then: there are two visits associated to pikachu
        assertThat(db.countVisitsFor(pikachu)) (2)
            .isEqualTo(2);
    }
}

class VisitServiceTest {
    @Test
    public void createVisitForToday_createsANewVisit_forTheCorrectPet() {
        // given: the amount of visits for pikachu is captured
        Long visitAmountBefore = db.countVisitsFor(pikachu);

        // when: logic is executed for the pikachus identification number
        visit = visitService.createVisitForToday(
                pikachu.getIdentificationNumber()
        );
        // then: there is one more visit associated to pikachu

        assertThat(db.countVisitsFor(pikachu))
            .isEqualTo(visitAmountBefore + 1);
    }
}

public class DiseaseWarningMailingServiceTest {

    private final String ALABASTIA = "Alabastia";
    private final String ELECTRICAL_OVERCHARGING = "Electrical overcharging";
    // ...
    private PetType electricType; (1)
    private List<Pet> electricPetsFromAlabastia;

    @BeforeEach
    public void loadTestDataAndVerifyItsCorrectness() {  (2)
        // given: there is an 'Electric' pet type
        electricType = db.petTypeWithName("Electric");

        assertThat(electricType)
            .isNotNull();

        // and: there is exactly one electric pet from Alabastia
        electricPetsFromAlabastia = db.petsWithTypeFromCity(
            electricType,
            ALABASTIA,
            "pet-with-owner-and-type"
        );

        assertThat(electricPetsFromAlabastia)
            .hasSize(1);
    }

    // different test cases...

    private int warnAboutElectricalOverchargingIn(String city) { (3)
        return diseaseWarningMailingService.warnAboutDisease(
            electricType,
            ELECTRICAL_OVERCHARGING,
            city
        );
    }

    @AfterEach
    public void clearOutgoingEmails() { (4)
        db.outgoingEmails()
            .forEach(db::removeEntity);
    }
}

public class DiseaseWarningMailingServiceTest {
    // ...
    @Test
    public void warnAboutDisease_createsAnEmail_forEachEffectedPet() {
        // given: there is only one electric pet from Alabastia
        assertThat(electricPetsFromAlabastia)
            .hasSize(1); (1)
        // when: a warning is send out for Alabastia
        int effectedPets = warnAboutElectricalOverchargingIn(ALABASTIA);  (2)
        // then: the amount of effected Pets match the expected amount of one
        assertThat(effectedPets)
            .isEqualTo(1);
        // and: there is one outgoing Email for CUBAs Email Sending Functionality
        assertThat(db.outgoingEmails())
            .hasSize(1);  (4)
    }
    // ...
}

public class DiseaseWarningMailingServiceTest {
    // ...
    @Test
    public void warnAboutDisease_createsNoEmails_forACityWithoutOwners() {

        // given: there is no owner in the Cerulean City
        assertThat(db.ownersFromCity("Cerulean City")) (1)
            .isEmpty();
        // when: a warning is send out for Cerulean City
        int effectedPets = warnAboutElectricalOverchargingIn("Cerulean City");
        // then: no Pet should be effected
        assertThat(effectedPets)
            .isEqualTo(0);
        // and: no outgoing Email should be stored in the DB
        assertThat(db.outgoingEmails())
            .hasSize(0);
    }
    // ...
}

public class DiseaseWarningMailingServiceTest {
    // ...
  @Nested
  class WarnAboutDiseaseWithAdditionalElectricPetAndOwner { (1)

        private Owner falkner; (2)
        private Pet zapdos;

        @BeforeEach
        void createAdditionalElectricPetAndOwner() {
            // given: there is a second owner in Alabastia with an electric pet without an Email Address
            falkner = db.createOwner("Falkner", null, "Miastreet 234", ALABASTIA);
            zapdos = db.createPet("123", "Zapdos", electricType, falkner);
        }

        @Test
        public void warnAboutDisease_createsNoEmail_whenTheOwnerDoesNotHaveAnEmailAddress() {

        // given: there is two pets with type 'electric' from Alabastia
        List<Pet> electricPetsFromAlabastia =
            db.petsWithTypeFromCity(electricType, ALABASTIA);
        assertThat(electricPetsFromAlabastia)
            .hasSize(2);
        // when: a warning is send out for Alabastia
        int effectedPets = warnAboutElectricalOverchargingIn(ALABASTIA);
        // then: only one email was send out for the pet with an owner that has an email
        assertThat(effectedPets)
              .isEqualTo(1);
        assertThat(db.outgoingEmails())
              .hasSize(1);
        }

        @AfterEach
        void removeAdditionalElectricPetAndOwner() { (3)
            db.removeEntity(zapdos);
            db.removeEntity(falkner);
        }
    }
    // ...
}