@Test
public void shouldFindCarsWithFindCommandAndNamedQuery() throws Exception {
// String uniqueColorForTest = "black-and-pink-with-ruby-named-query";
Car exampleCar =
CarBuilder.aCar().withManufacturer(UUID.randomUUID().toString()).withYear(2000).build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar().withManufacturer(UUID.randomUUID().toString()).withYear(2005).build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
// Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
FindCommand<Car> findCommand = FindCommand.create(Car.class);
findCommand.withSearchFilter("year", "2000").withNamedQuery("Car.findGreaterThanYear");
List<Car> foundCars = carRepository.findItemsWith(findCommand);
assertThat(foundCars).isNotNull().hasSize(10);
FindCommand<Car> findCommand2 =
FindCommand.create(Car.class)
.withSearchFilter("year", "2005")
.withNamedQuery("Car.findGreaterThanYear");
List<Car> foundCarsByColor = carRepository.findItemsWith(findCommand2);
assertThat(foundCarsByColor).isNotNull().hasSize(5);
/*FindCommand<Car> findCommand3 = FindCommand.create(Car.class)
.withNamedQuery("Car.findGreaterThanYear");
findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand3.withSearchFilter("color", uniqueColorForTest);
List<Car> foundCarsByManufacturerAndColor = carRepository.findItemsWith(findCommand3);
assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);*/
}
@Test
public void shouldCountCarsWithFindCommand() throws Exception {
String uniqueColorForTest = "color-shouldCountCarsWithFindCommand";
Car exampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
// Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
FindCommand<Car> findCommand = FindCommand.create(Car.class);
findCommand.withSearchFilter("manufacturer", exampleCar.getManufacturer());
long foundCars = carRepository.findTotalItemCount(findCommand);
assertThat(foundCars).isEqualTo(10);
FindCommand<Car> findCommand2 = FindCommand.create(Car.class);
findCommand2.withSearchFilter("color", uniqueColorForTest);
long foundCarsByColor = carRepository.findTotalItemCount(findCommand2);
assertThat(foundCarsByColor).isEqualTo(15);
FindCommand<Car> findCommand3 = FindCommand.create(Car.class);
findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand3.withSearchFilter("color", uniqueColorForTest);
long foundCarsByManufacturerAndColor = carRepository.findTotalItemCount(findCommand3);
assertThat(foundCarsByManufacturerAndColor).isEqualTo(10);
}
@Test
public void shouldFindCarsByExample() throws Exception {
String uniqueColor = "unique-color-" + UUID.randomUUID().toString();
Car exampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColor)
.build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColor)
.build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
List<Car> foundCars = carRepository.findByExample(searchByManufacturerExampleCar);
assertThat(foundCars).isNotNull().hasSize(10);
Car searchByColorExampleCar = new Car(null, 0, null, uniqueColor);
List<Car> foundCarsByColor = carRepository.findByExample(searchByColorExampleCar);
assertThat(foundCarsByColor).isNotNull().hasSize(15);
Car searchByManufacturerAndColorExampleCar =
new Car(null, 0, exampleCar.getManufacturer(), uniqueColor);
List<Car> foundCarsByManufacturerAndColor =
carRepository.findByExample(searchByManufacturerAndColorExampleCar);
assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);
}
@Test
public void shouldFindCarsAndPaginateWithFindCommand() throws Exception {
String uniqueColorForTest = "black-and-pink-with-ruby";
Car exampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
FindCommand<Car> findCommand = FindCommand.create(Car.class);
findCommand
.withSearchFilter("manufacturer", exampleCar.getManufacturer())
.forCurrentPageFirstIndex(0)
.forPageSize(7);
// carRepository.findTotalItemCount(findCommand);
List<Car> foundCars = carRepository.findItemsWith(findCommand);
assertThat(foundCars).isNotNull().hasSize(7);
findCommand.forCurrentPageFirstIndex(1);
foundCars = carRepository.findItemsWith(findCommand);
assertThat(foundCars).isNotNull().hasSize(7);
findCommand.forCurrentPageFirstIndex(9);
foundCars = carRepository.findItemsWith(findCommand);
assertThat(foundCars).isNotNull().hasSize(1);
FindCommand<Car> findCommand3 = FindCommand.create(Car.class);
findCommand3
.withSearchFilter("manufacturer", exampleCar.getManufacturer())
.withSearchFilter("color", uniqueColorForTest)
.forPageSize(5)
.forCurrentPageFirstIndex(7);
List<Car> foundCarsByManufacturerAndColor = carRepository.findItemsWith(findCommand3);
assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(3);
findCommand3.forPageSize(2);
List<Car> foundCarsByManufacturerAndColor2 = carRepository.findItemsWith(findCommand3);
assertThat(foundCarsByManufacturerAndColor2).isNotNull().hasSize(2);
}
@Test
public void shouldFindMultipleCarsAndRelatedTyresWithFindCommand() throws Exception {
String uniqueColorForTest = "black-and-pink-with-ruby-and-related-tyres";
String tyreManufacturer = "tyre-manufacturer-1";
Car exampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.withTyre(tyreManufacturer, 5)
.withTyre(tyreManufacturer, 5)
.withTyre(tyreManufacturer, 5)
.build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
// Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
FindCommand<Car> findCommand = FindCommand.create(Car.class);
findCommand.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand.withSearchFilter("tyreList.manufacturer", tyreManufacturer);
// List<Car> foundCars = carRepository.findItemsWith(findCommand);
int expectedSize = 10;
List<Car> foundCars = carRepository.findItemsWith(findCommand);
log.info("foundCars={}", foundCars);
assertThat(foundCars).isNotNull().hasSize(expectedSize);
long count = carRepository.findTotalItemCount(findCommand);
assertThat(count).isNotNull().isEqualTo(expectedSize);
/*FindCommand<Car> findCommand2 = FindCommand.create(Car.class);
findCommand2.withSearchFilter("color", uniqueColorForTest);
List<Car> foundCarsByColor = carRepository.findItemsWith(findCommand2);
assertThat(foundCarsByColor).isNotNull().hasSize(15);
FindCommand<Car> findCommand3 = FindCommand.create(Car.class);
findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand3.withSearchFilter("color", uniqueColorForTest);
List<Car> foundCarsByManufacturerAndColor = carRepository.findItemsWith(findCommand3);
assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);*/
}
@Test
public void shouldReturnNonNullWhenFindCarWithValidId() throws Exception {
Car car = CarBuilder.aCar().build();
saveDomainEntityToRepositoryWithTransaction(car);
Car foundCar = carRepository.findById(car.getId());
assertThat(foundCar).isNotNull();
}
@Test(/* expected = RuntimeException.class */ )
public void shouldReturnNullWhenFindCarWithInvalidManufacturer() {
// setup test?
// Use import.sql for hibernate auto-insert?
Car exampleCar = CarBuilder.aCar().withManufacturer("invalid-manufacturer").build();
List<Car> foundCars = carRepository.findByExample(exampleCar);
assertThat(foundCars).isEmpty();
}
@Test
public void shouldReturnWithoutErrorWhenSavingNewCar()
throws NotSupportedException, SystemException, SecurityException, IllegalStateException,
RollbackException, HeuristicMixedException, HeuristicRollbackException {
Car car = CarBuilder.aCar().build();
saveDomainEntityToRepositoryWithTransaction(car);
assertThat(car).isNotNull();
}
@Test
public void shouldFindCarsAndRelatedDriversWithFindCommand() throws Exception {
String uniqueColorForTest = "black-and-pink-with-ruby-and-related-drivers";
Car exampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(exampleCar, 10);
Car secondExampleCar =
CarBuilder.aCar()
.withManufacturer(UUID.randomUUID().toString())
.withColor(uniqueColorForTest)
.build();
saveNewCopiesOfCarToRepository(secondExampleCar, 5);
// Car searchByManufacturerExampleCar = new Car(null, 0, exampleCar.getManufacturer(), null);
FindCommand<Car> findCommand = FindCommand.create(Car.class);
findCommand.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand.withSearchFilter("driver.name", exampleCar.getDriverName());
List<Car> foundCars = carRepository.findItemsWith(findCommand);
// List<Car> foundCars = carRepository.tempfindItems(findCommand);
assertThat(foundCars).isNotNull().hasSize(10);
/*FindCommand<Car> findCommand2 = FindCommand.create(Car.class);
findCommand2.withSearchFilter("color", uniqueColorForTest);
List<Car> foundCarsByColor = carRepository.findItemsWith(findCommand2);
assertThat(foundCarsByColor).isNotNull().hasSize(15);
FindCommand<Car> findCommand3 = FindCommand.create(Car.class);
findCommand3.withSearchFilter("manufacturer", exampleCar.getManufacturer());
findCommand3.withSearchFilter("color", uniqueColorForTest);
List<Car> foundCarsByManufacturerAndColor = carRepository.findItemsWith(findCommand3);
assertThat(foundCarsByManufacturerAndColor).isNotNull().hasSize(10);*/
}
@Test
public void shouldReturnWithoutErrorWhenSavingExistingCarMultipleTimes()
throws NotSupportedException, SystemException, SecurityException, IllegalStateException,
RollbackException, HeuristicMixedException, HeuristicRollbackException {
Car car = CarBuilder.aCar().build();
saveDomainEntityToRepositoryWithTransaction(car);
car = carRepository.findById(car.getId());
car.setPrice(37);
saveDomainEntityToRepositoryWithTransaction(car);
assertThat(car).isNotNull();
car.setPrice(59);
saveDomainEntityToRepositoryWithTransaction(car);
assertThat(car).isNotNull();
}