public class UTSerieEquality extends AbstractDataEqualityTest<Serie> {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Serie> FACTORY = FactoryRepository.get(Serie.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<SerieSeason> SERIE_SEASON_FACTORY =
FactoryRepository.get(SerieSeason.class);
@Override
protected Serie getNewEntity() {
return FACTORY.getNew();
}
@Test
public void testUnchanged() throws Exception {
Serie entity = getEntity();
Serie copy = new Serie(entity);
assertEquals(entity, copy);
}
@Test
public void testDifferentSeason() throws Exception {
Serie entity = getEntity();
Serie copy = new Serie(entity);
entity.addSeason(SERIE_SEASON_FACTORY.getNext());
assertEquals(entity, copy);
}
}
@RunWith(Suite.class)
@Suite.SuiteClasses({
UTPersonSafety.class,
UTPerson.class,
UTPersonEquality.class,
UTPersonComparator.class,
UTPersonBuilderSafety.class,
UTPersonBuilder.class,
UTPersonDatabaseSupport.class
})
public class PersonTestSuite implements DataFactory<Person> {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Responsible> RESPONSIBLE_FACTORY =
FactoryRepository.get(Responsible.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Role> ROLE_FACTORY = FactoryRepository.get(Role.class);
private static long index = 0L;
@Override
public Person getNew() {
return getNew(true);
}
@Override
public Person getNext() {
return getNext(true);
}
@Override
public Person getNew(boolean withLink) {
Person.Builder builder = Person.builder().from(RESPONSIBLE_FACTORY.getNew(withLink));
if (withLink) {
builder.addRole(ROLE_FACTORY.getNew(false));
}
return builder.build();
}
@Override
public Person getNext(boolean withLink) {
Person.Builder builder = Person.builder().from(RESPONSIBLE_FACTORY.getNext(withLink));
if (withLink) {
builder.addRole(ROLE_FACTORY.getNext(false)).addRole(ROLE_FACTORY.getNext(false));
}
index += 1;
return builder.build();
}
}
public class UTAbstractBDSafety {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<AbstractBD> FACTORY = FactoryRepository.get(AbstractBD.class);
private static final Class<AbstractBD> CLASS = new Class<>(AbstractBD.class);
private AbstractBD entity;
@Before
public void setUp() throws Exception {
entity = FACTORY.getNew();
}
@After
public void tearDown() throws Exception {
entity = null;
}
@Test(expected = ConstraintViolationException.class)
public void testBuilderConstructor_Null() throws Exception {
Validator.validate(CLASS.getConstructor(AbstractBD.Init.class), new Object[] {null});
}
@Test(expected = ConstraintViolationException.class)
public void testCopyConstructor_Null() throws Exception {
Validator.validate(CLASS.getConstructor(AbstractBD.class), new Object[] {null});
}
@Test(expected = ConstraintViolationException.class)
public void testSetIssueNumber_Null() throws Exception {
Validator.validate(entity, CLASS.getMethod("setIssueNumber", Long.class), new Object[] {null});
}
}
public class UTBookSerieDatabaseDAO extends AbstractDAOTest<BookSerieDatabaseDAO, BookSerie> {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<BookSerie> FACTORY = FactoryRepository.get(BookSerie.class);
private static final String ALTERNATIVE_TITLE = "AlternativeTitle";
@Override
protected BookSerieDatabaseDAO initDAO() {
return new BookSerieDatabaseDAO();
}
@Override
protected Object getEntityId(final BookSerie entity) {
return entity.getId();
}
@Override
protected void changeEntity(final BookSerie entity) {
entity.setTitle(ALTERNATIVE_TITLE);
}
@Override
protected void assertChangedPropertyEquals(final BookSerie foundEntity) {
assertEquals(ALTERNATIVE_TITLE, foundEntity.getTitle());
}
@Override
protected BookSerie getNewData() {
return FACTORY.getNext();
}
}
@RunWith(Suite.class)
@Suite.SuiteClasses({
UTSerieSeasonSafety.class,
UTSerieSeason.class,
UTSerieSeasonEquality.class,
UTSerieSeasonComparator.class,
UTSerieSeasonBuilderSafety.class,
UTSerieSeasonBuilder.class,
UTSerieSeasonDatabaseSupport.class
})
public class SerieSeasonTestSuite implements DataFactory<SerieSeason> {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<BaseMedia> BASE_MEDIA_FACTORY =
FactoryRepository.get(BaseMedia.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Serie> SERIE_FACTORY = FactoryRepository.get(Serie.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<EpisodeSerie> EPISODE_SERIE_FACTORY =
FactoryRepository.get(EpisodeSerie.class);
private Long index = 0L;
@Override
public SerieSeason getNew() {
return getNew(true);
}
@Override
public SerieSeason getNext() {
return getNext(true);
}
@Override
public SerieSeason getNew(boolean withLink) {
SerieSeason.Builder builder =
SerieSeason.builder().from(BASE_MEDIA_FACTORY.getNew(withLink)).setSeasonNumber(1L);
if (withLink) {
builder.setSerie(SERIE_FACTORY.getNew(false)).addEpisode(EPISODE_SERIE_FACTORY.getNew(false));
}
return builder.build();
}
@Override
public SerieSeason getNext(boolean withLink) {
SerieSeason.Builder builder =
SerieSeason.builder().from(BASE_MEDIA_FACTORY.getNew(withLink)).setSeasonNumber(index);
if (withLink) {
builder
.setSerie(SERIE_FACTORY.getNext())
.addEpisode(EPISODE_SERIE_FACTORY.getNext())
.addEpisode(EPISODE_SERIE_FACTORY.getNext());
}
index += 1;
return builder.build();
}
}
public class UTVideo {
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Video> FACTORY = FactoryRepository.get(Video.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Role> ROLE_FACTORY = FactoryRepository.get(Role.class);
@SuppressWarnings(WarningTypes.UNCHECKED_CAST)
private static final DataFactory<Responsible> RESPONSIBLE_FACTORY =
FactoryRepository.get(Responsible.class);
private Video entity;
private Collection<Role> actors = new HashSet<>();
private Collection<Responsible> producers;
private Collection<Responsible> directors;
private Collection<Responsible> composers;
private Collection<Responsible> scenarists;
private Collection<Responsible> otherStaffMembers;
@Before
public void setUp() throws Exception {
entity = FACTORY.getNext();
actors = entity.getActors();
producers = entity.getProducers();
directors = entity.getDirectors();
composers = entity.getComposers();
scenarists = entity.getScenarists();
otherStaffMembers = entity.getOtherStaffMembers();
}
@After
public void tearDown() throws Exception {
otherStaffMembers = null;
scenarists = null;
composers = null;
directors = null;
producers = null;
actors = null;
entity = null;
}
@Test
public void testCopyConstructor() throws Exception {
Video copy = new FakeVideo(entity);
assertEquals(entity, copy);
}
@Test
public void testSetDuration() throws Exception {
entity.setDuration(Duration.ofMinutes(90));
assertEquals(Duration.ofMinutes(90), entity.getDuration());
}
@Test
public void testAddAllProducers() throws Exception {
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
producers.addAll(toAdd);
entity.addAllProducers(toAdd);
assertEquals(producers, entity.getProducers());
}
@Test
public void testAddProducer() throws Exception {
Responsible toAdd = RESPONSIBLE_FACTORY.getNext();
producers.add(toAdd);
entity.addProducer(toAdd);
assertEquals(producers, entity.getProducers());
}
@Test
public void testRemoveAllProducers() throws Exception {
Responsible base = RESPONSIBLE_FACTORY.getNext();
Responsible second = RESPONSIBLE_FACTORY.getNext();
Responsible third = RESPONSIBLE_FACTORY.getNext();
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Responsible> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
producers.addAll(toAdd);
entity.addAllProducers(toAdd);
producers.removeAll(toRemove);
entity.removeAllProducers(toRemove);
assertEquals(producers, entity.getProducers());
}
@Test
public void testRemoveProducer() throws Exception {
Responsible toRemove = entity.getProducers().iterator().next();
producers.remove(toRemove);
entity.removeProducer(toRemove);
assertEquals(producers, entity.getProducers());
}
@Test
public void testAddAllDirectors() throws Exception {
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
directors.addAll(toAdd);
entity.addAllDirectors(toAdd);
assertEquals(directors, entity.getDirectors());
}
@Test
public void testAddDirector() throws Exception {
Responsible toAdd = RESPONSIBLE_FACTORY.getNext();
directors.add(toAdd);
entity.addDirector(toAdd);
assertEquals(directors, entity.getDirectors());
}
@Test
public void testRemoveAllDirectors() throws Exception {
Responsible base = RESPONSIBLE_FACTORY.getNext();
Responsible second = RESPONSIBLE_FACTORY.getNext();
Responsible third = RESPONSIBLE_FACTORY.getNext();
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Responsible> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
directors.addAll(toAdd);
entity.addAllDirectors(toAdd);
directors.removeAll(toRemove);
entity.removeAllDirectors(toRemove);
assertEquals(directors, entity.getDirectors());
}
@Test
public void testRemoveDirector() throws Exception {
Responsible toRemove = entity.getDirectors().iterator().next();
directors.remove(toRemove);
entity.removeDirector(toRemove);
assertEquals(directors, entity.getDirectors());
}
@Test
public void testAddAllComposers() throws Exception {
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
composers.addAll(toAdd);
entity.addAllComposers(toAdd);
assertEquals(composers, entity.getComposers());
}
@Test
public void testAddComposer() throws Exception {
Responsible toAdd = RESPONSIBLE_FACTORY.getNext();
composers.add(toAdd);
entity.addComposer(toAdd);
assertEquals(composers, entity.getComposers());
}
@Test
public void testRemoveAllComposers() throws Exception {
Responsible base = RESPONSIBLE_FACTORY.getNext();
Responsible second = RESPONSIBLE_FACTORY.getNext();
Responsible third = RESPONSIBLE_FACTORY.getNext();
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Responsible> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
composers.addAll(toAdd);
entity.addAllComposers(toAdd);
composers.removeAll(toRemove);
entity.removeAllComposers(toRemove);
assertEquals(composers, entity.getComposers());
}
@Test
public void testRemoveComposer() throws Exception {
Responsible toRemove = entity.getComposers().iterator().next();
composers.remove(toRemove);
entity.removeComposer(toRemove);
assertEquals(composers, entity.getComposers());
}
@Test
public void testAddAllScenarists() throws Exception {
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
scenarists.addAll(toAdd);
entity.addAllScenarists(toAdd);
assertEquals(scenarists, entity.getScenarists());
}
@Test
public void testAddScenarist() throws Exception {
Responsible toAdd = RESPONSIBLE_FACTORY.getNext();
scenarists.add(toAdd);
entity.addScenarist(toAdd);
assertEquals(scenarists, entity.getScenarists());
}
@Test
public void testRemoveAllScenarists() throws Exception {
Responsible base = RESPONSIBLE_FACTORY.getNext();
Responsible second = RESPONSIBLE_FACTORY.getNext();
Responsible third = RESPONSIBLE_FACTORY.getNext();
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Responsible> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
scenarists.addAll(toAdd);
entity.addAllScenarists(toAdd);
scenarists.removeAll(toRemove);
entity.removeAllScenarists(toRemove);
assertEquals(scenarists, entity.getScenarists());
}
@Test
public void testRemoveScenarist() throws Exception {
Responsible toRemove = entity.getScenarists().iterator().next();
scenarists.remove(toRemove);
entity.removeScenarist(toRemove);
assertEquals(scenarists, entity.getScenarists());
}
@Test
public void testAddAllOtherStaffMembers() throws Exception {
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
toAdd.add(RESPONSIBLE_FACTORY.getNext());
otherStaffMembers.addAll(toAdd);
entity.addAllOtherStaffMembers(toAdd);
assertEquals(otherStaffMembers, entity.getOtherStaffMembers());
}
@Test
public void testAddOtherStaffMember() throws Exception {
Responsible toAdd = RESPONSIBLE_FACTORY.getNext();
otherStaffMembers.add(toAdd);
entity.addOtherStaffMember(toAdd);
assertEquals(otherStaffMembers, entity.getOtherStaffMembers());
}
@Test
public void testRemoveAllOtherStaffMembers() throws Exception {
Responsible base = RESPONSIBLE_FACTORY.getNext();
Responsible second = RESPONSIBLE_FACTORY.getNext();
Responsible third = RESPONSIBLE_FACTORY.getNext();
Collection<Responsible> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Responsible> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
otherStaffMembers.addAll(toAdd);
entity.addAllOtherStaffMembers(toAdd);
otherStaffMembers.removeAll(toRemove);
entity.removeAllOtherStaffMembers(toRemove);
assertEquals(otherStaffMembers, entity.getOtherStaffMembers());
}
@Test
public void testRemoveOtherStaffMember() throws Exception {
Responsible toRemove = entity.getOtherStaffMembers().iterator().next();
otherStaffMembers.remove(toRemove);
entity.removeOtherStaffMember(toRemove);
assertEquals(otherStaffMembers, entity.getOtherStaffMembers());
}
@Test
public void testGetRoleForActor() throws Exception {
Role role = ROLE_FACTORY.getNext();
entity.addActor(role);
assertTrue(entity.getRoleForActor(role.getActor()).contains(role.getRole()));
}
@Test
public void testGetActorsForRole() throws Exception {
Role role = ROLE_FACTORY.getNext();
entity.addActor(role);
assertTrue(entity.getActorsForRole(role.getRole()).contains(role.getActor()));
}
@Test
public void testAddAllActors() throws Exception {
Collection<Role> toAdd = new HashSet<>();
toAdd.add(ROLE_FACTORY.getNext());
toAdd.add(ROLE_FACTORY.getNext());
toAdd.add(ROLE_FACTORY.getNext());
actors.addAll(toAdd);
entity.addAllActors(toAdd);
assertEquals(actors, entity.getActors());
}
@Test
public void testAddActor() throws Exception {
Role toAdd = ROLE_FACTORY.getNext();
actors.add(toAdd);
entity.addActor(toAdd);
assertEquals(actors, entity.getActors());
}
@Test
public void testRemoveAllActors() throws Exception {
Role base = ROLE_FACTORY.getNext();
Role second = ROLE_FACTORY.getNext();
Role third = ROLE_FACTORY.getNext();
Collection<Role> toAdd = new HashSet<>();
toAdd.add(base);
toAdd.add(second);
toAdd.add(third);
Collection<Role> toRemove = new HashSet<>();
toRemove.add(second);
toRemove.add(third);
actors.addAll(toAdd);
entity.addAllActors(toAdd);
actors.removeAll(toRemove);
entity.removeAllActors(toRemove);
assertEquals(actors, entity.getActors());
}
@Test
public void testRemoveActor() throws Exception {
Role toRemove = entity.getActors().iterator().next();
actors.remove(toRemove);
entity.removeActor(toRemove.getActor());
assertEquals(actors, entity.getActors());
}
@Test
public void testRemoveRole() throws Exception {
Role toRemove = entity.getActors().iterator().next();
actors.remove(toRemove);
entity.removeRole(toRemove.getRole());
assertEquals(actors, entity.getActors());
}
}