Java tutorial
package rmblworx.tools.timey; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.fail; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.timeout; import static org.mockito.Mockito.verify; import java.util.Collection; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import rmblworx.tools.timey.event.AlarmExpiredEvent; import rmblworx.tools.timey.event.AlarmsModifiedEvent; import rmblworx.tools.timey.event.TimeyEvent; import rmblworx.tools.timey.event.TimeyEventListener; import rmblworx.tools.timey.vo.AlarmDescriptor; import rmblworx.tools.timey.vo.TimeDescriptor; /* * Copyright 2014-2015 Christian Raue * MIT License http://opensource.org/licenses/mit-license.php */ /** * Tests fr die Ereignisse der Alarm-Funktionalitt. * @author Christian Raue {@literal <christian.raue@gmail.com>} */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "/spring-timey-context.xml", "/alarm-spring-timey-context.xml" }) public class AlarmEventsTest { /** * Max. Zeit (in ms), die auf das Eintreten eines Ereignisses gewartet werden soll. */ protected static final int WAIT_FOR_EVENT = 5000; private final ArgumentCaptor<TimeyEvent> eventCaptor = ArgumentCaptor.forClass(TimeyEvent.class); private final long now = System.currentTimeMillis(); private final long oneHourAgo = now - 60 * 60 * 1000; private final long inOneMinute = now + 60 * 1000; /** * Inaktiver Alarm, der vor einer Stunde ausgelst wurde. */ private final AlarmDescriptor alarmOneHourAgo = new AlarmDescriptor(new TimeDescriptor(oneHourAgo), false, "alter Alarm", "", null); /** * Alarm, der in einer Minute ausgelst wird. */ private final AlarmDescriptor alarmInOneMinute = new AlarmDescriptor(new TimeDescriptor(inOneMinute), true, "Zukunftsalarm", "", null); /** * Jetzt auzulsender Alarm. */ private final AlarmDescriptor alarmNow = new AlarmDescriptor(new TimeDescriptor(now), true, "relevanter Alarm", "", null); private ITimey facade; private TimeyEventListener eventListener; @Before public void setUp() { facade = new TimeyFacade(); // alle Alarme lschen for (final AlarmDescriptor alarm : facade.getAllAlarms()) { facade.removeAlarm(alarm); } eventListener = mock(TimeyEventListener.class); facade.addEventListener(eventListener); } /** * Testet Ereignisse beim Anlegen eines inaktiven Alarms. */ @Test public final void testCreateDisabledAlarmNoExpiredEvent() { facade.setAlarm(alarmOneHourAgo); final Class<?>[] expectedEvents = new Class<?>[] { AlarmsModifiedEvent.class }; // sicherstellen, dass erwartete Ereignisse ausgelst wurden verify(eventListener, timeout(WAIT_FOR_EVENT).times(expectedEvents.length)) .handleEvent(eventCaptor.capture()); final List<TimeyEvent> events = eventCaptor.getAllValues(); assertEquals(expectedEvents.length, events.size()); assertContainsAllAndOnlyTypes(events, expectedEvents); } /** * Testet Ereignisse beim Anlegen eines Alarms, der erst irgendwann spter ausgelst wird. */ @Test public final void testCreateFutureAlarmNoExpiredEvent() { facade.setAlarm(alarmInOneMinute); final Class<?>[] expectedEvents = new Class<?>[] { AlarmsModifiedEvent.class }; // sicherstellen, dass erwartete Ereignisse ausgelst wurden verify(eventListener, timeout(WAIT_FOR_EVENT).times(expectedEvents.length)) .handleEvent(eventCaptor.capture()); final List<TimeyEvent> events = eventCaptor.getAllValues(); assertEquals(expectedEvents.length, events.size()); assertContainsAllAndOnlyTypes(events, expectedEvents); } /** * Testet Ereignisse beim Anlegen eines jetzt auzulsenden Alarms. */ @Test public final void testCreateAlarmEvents() { facade.setAlarm(alarmNow); final Class<?>[] expectedEvents = new Class<?>[] { AlarmsModifiedEvent.class, // Anlegen des Alarms AlarmsModifiedEvent.class, // Deaktivierung des Alarms beim Auslsen AlarmExpiredEvent.class, // Auslsen des Alarms }; // sicherstellen, dass erwartete Ereignisse ausgelst wurden verify(eventListener, timeout(WAIT_FOR_EVENT).times(expectedEvents.length)) .handleEvent(eventCaptor.capture()); final List<TimeyEvent> events = eventCaptor.getAllValues(); assertEquals(expectedEvents.length, events.size()); assertContainsAllAndOnlyTypes(events, expectedEvents); for (final TimeyEvent event : events) { if (event instanceof AlarmExpiredEvent) { final AlarmDescriptor alarm = ((AlarmExpiredEvent) event).getAlarmDescriptor(); assertNotNull(alarm); assertEquals(alarmNow.getDescription(), alarm.getDescription()); assertFalse(alarm.getIsActive()); } } } /** * Testet Ereignisse beim Anlegen mehrerer Alarme. */ @Test public final void testCreateSeveralAlarmsEvents() { facade.setAlarm(alarmOneHourAgo); facade.setAlarm(alarmInOneMinute); facade.setAlarm(alarmNow); final Class<?>[] expectedEvents = new Class<?>[] { AlarmsModifiedEvent.class, // Anlegen ... AlarmsModifiedEvent.class, // ... der drei ... AlarmsModifiedEvent.class, // ... Alarme AlarmsModifiedEvent.class, // Deaktivierung des Alarms beim Auslsen AlarmExpiredEvent.class, // Auslsen des Alarms }; // sicherstellen, dass erwartete Ereignisse ausgelst wurden verify(eventListener, timeout(WAIT_FOR_EVENT).times(expectedEvents.length)) .handleEvent(eventCaptor.capture()); final List<TimeyEvent> events = eventCaptor.getAllValues(); assertEquals(expectedEvents.length, events.size()); assertContainsAllAndOnlyTypes(events, expectedEvents); } /** * Stellt sicher, * <ul> * <li>dass jedes Element in <code>items</code> von einem der in <code>types</code> aufgefhrten Typen ist und</li> * <li>dass jeder in <code>types</code> aufgefhrte Typ in <code>items</code> vorkommt.</li> * </ul> * @param items Elemente * @param types Typen */ protected final void assertContainsAllAndOnlyTypes(final Collection<?> items, final Class<?>... types) { assertContainsAllTypes(items, types); assertContainsOnlyTypes(items, types); } /** * Stellt sicher, dass jeder in <code>types</code> aufgefhrte Typ in <code>items</code> vorkommt. * @param items Elemente * @param types Typen */ protected final void assertContainsOnlyTypes(final Collection<?> items, final Class<?>... types) { for (final Object item : items) { assertIsOfOneType(item, types); } } /** * Stellt sicher, dass das Element <code>item</code> von einem der in <code>types</code> aufgefhrten Typen ist. * @param item Element * @param types Typen */ protected final void assertIsOfOneType(final Object item, final Class<?>... types) { for (final Class<?> klass : types) { if (klass.isInstance(item)) { return; } } fail(String.format("%s ist vom unerwarteten Typ %s.", item, item.getClass())); } /** * Stellt sicher, dass jedes Element in <code>items</code> von einem der in <code>types</code> aufgefhrten Typen ist. * @param items Elemente * @param types Typen */ protected final void assertContainsAllTypes(final Collection<?> items, final Class<?>... types) { for (final Class<?> klass : types) { assertContainsElementOfType(items, klass); } } /** * Stellt sicher, dass ein Element des Typs <code>type</code> in <code>items</code> vorkommt. * @param items Elemente * @param type Typ */ protected final void assertContainsElementOfType(final Collection<?> items, final Class<?> type) { for (final Object item : items) { if (type.isInstance(item)) { return; } } fail(String.format("%s enthlt kein Element vom Typ %s.", items, type)); } }