package com.atlassian.johnson;
   
   import com.atlassian.johnson.event.Event;
   import com.atlassian.johnson.event.EventType;
   import org.hamcrest.FeatureMatcher;
   import org.hamcrest.Matcher;
   import org.junit.Before;
   import org.junit.Test;
   
  import javax.annotation.Nonnull;
  import java.util.Collection;
  import java.util.List;
  import java.util.Optional;
  import java.util.function.Predicate;
  
  import static java.util.Arrays.stream;
  import static java.util.Optional.empty;
  import static java.util.stream.Collectors.toList;
  import static org.hamcrest.Matchers.contains;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.assertTrue;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.when;
  
  public class DefaultJohnsonEventContainerTest {
  
      private static final Predicate<Event> MATCH_NONE = event -> false;
      private static final Predicate<Event> MATCH_ALL = event -> true;
  
      @Nonnull
      private static Event eventWithProgress(boolean hasProgress) {
          final Event event = mock(Event.class);
          when(event.hasProgress()).thenReturn(hasProgress);
          return event;
      }
  
      @Nonnull
      private static List<Matcher<? super Event>> eventsWithDescriptions(final String... descriptions) {
          return stream(descriptions).map(DefaultJohnsonEventContainerTest::eventWithDescription).collect(toList());
      }
  
      @Nonnull
      private static Matcher<? super Event> eventWithDescription(final String description) {
          return new FeatureMatcher<Event, String>(equalTo(description), "an Event with description", "description") {
              @Override
              protected String featureValueOf(Event actual) {
                  return actual.getDesc();
              }
          };
      }
  
      private DefaultJohnsonEventContainer container;
  
      @Before
      public void setUp() {
          container = new DefaultJohnsonEventContainer();
      }
  
      @Test
      public void containerShouldAddAndRemoveEvents() {
          // no events at the start!
          assertFalse(container.hasEvents());
  
          // add an event and check it exists
          final Event event = new Event(new EventType("systemic", "Systemic Anomaly"), "There is an anomaly in the matrix");
          container.addEvent(event);
          assertTrue(container.hasEvents());
          final Collection<Event> containerEvents = container.getEvents();
          assertEquals(1, containerEvents.size());
          assertTrue(containerEvents.contains(event));
  
          // now remove the event and check it's gone
          container.removeEvent(event);
          assertFalse(container.hasEvents());
          assertEquals(0, container.getEvents().size());
      }
  
      @Test
      public void eventsReturnedInOrderOfAddition() {
          // Set up
          for (int i = 0; i < 5; i++) {
              container.addEvent(new Event(new EventType("", ""), Integer.toString(i)));
          }
  
          // Invoke and check
          assertTrue(container.hasEvents());
          assertThat(container.getEvents(), contains(eventsWithDescriptions("0", "1", "2", "3", "4")));
      }
  
      @Test(expected = UnsupportedOperationException.class)
      public void returnedCollectionOfEventsShouldNotBeModifiable() {
          container.getEvents().add(new Event(new EventType("", ""), ""));
      }
  
      @Test
     public void getEventsMatchingPredicateShouldApplyThatPredicate() {
         // Set up
         final Event eventWithProgress = eventWithProgress(true);
         container.addEvent(eventWithProgress);
         container.addEvent(eventWithProgress(false));
 
         // Invoke
         final Collection<Event> returnedEvents = container.getEvents(Event::hasProgress);
 
         // Check
         assertThat(returnedEvents, contains(eventWithProgress));
     }
 
     @Test
     public void hasEventShouldReturnFalseWhenNoEventsMatchThePredicate() {
         // Set up
         container.addEvent(mock(Event.class));
 
         // Invoke
         final boolean hasEvent = container.hasEvent(MATCH_NONE);
 
         // Check
         assertFalse(hasEvent);
     }
 
     @Test
     public void hasEventShouldReturnTrueWhenAnEventMatchesThePredicate() {
         // Set up
         container.addEvent(mock(Event.class));
 
         // Invoke
         final boolean hasEvent = container.hasEvent(MATCH_ALL);
 
         // Check
         assertTrue(hasEvent);
     }
 
     @Test
     public void firstEventShouldBeEmptyWhenContainerIsEmpty() {
         // Invoke
         final Optional<Event> maybeEvent = container.firstEvent(MATCH_ALL);
 
         // Check
         assertThat(maybeEvent, is(empty()));
     }
 
     @Test
     public void firstEventShouldBeNonEmptyWhenContainerIsNotEmpty() {
         // Set up
         final Event event = mock(Event.class);
         container.addEvent(event);
 
         // Invoke
         final Optional<Event> maybeEvent = container.firstEvent(MATCH_ALL);
 
         // Check
         assertThat(maybeEvent, is(Optional.of(event)));
     }
 
     @Test
     public void firstEventShouldBeActualFirstEventWhenMultipleEventsArePresent() {
         // Set up
         final Event event1 = mock(Event.class);
         container.addEvent(event1);
         container.addEvent(mock(Event.class));
 
         // Invoke
         final Optional<Event> maybeEvent = container.firstEvent(MATCH_ALL);
 
         // Check
         assertThat(maybeEvent, is(Optional.of(event1)));
     }
 }