package com.atlassian.johnson.event;
   
   import com.atlassian.johnson.Johnson;
   import org.junit.After;
   import org.junit.Before;
   import org.junit.Test;
   
   import java.util.function.Predicate;
   
  import static com.atlassian.johnson.event.EventLevels.error;
  import static com.atlassian.johnson.event.EventLevels.fatal;
  import static com.atlassian.johnson.event.EventLevels.warning;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.when;
  
  public class EventPredicatesTest {
  
      private static final String ATTRIBUTE_NAME = "foo";
  
      private static Event eventWithAttribute(final Object value) {
          final Event event = mock(Event.class);
          when(event.getAttribute(ATTRIBUTE_NAME)).thenReturn(value);
          return event;
      }
  
      private static Event eventWithLevel(final EventLevel eventLevel) {
          final Event event = mock(Event.class);
          when(event.getLevel()).thenReturn(eventLevel);
          return event;
      }
  
      private static Event eventWithType(final EventType eventType) {
          final Event event = mock(Event.class);
          when(event.getKey()).thenReturn(eventType);
          return event;
      }
  
      @Before
      public void initialiseJohnson() {
          Johnson.initialize("test-johnson-config.xml");
      }
  
      @After
      public void terminateJohnson() {
          Johnson.terminate();
      }
  
      @Test
      public void warningOrErrorPredicateShouldOnlyMatchEventsWithEitherOfThoseLevels() {
          // Invoke
          final Predicate<Event> predicate = EventPredicates.level(error(), warning());
  
          // Check
          assertThat(predicate.test(eventWithLevel(error())), is(true));
          assertThat(predicate.test(eventWithLevel(warning())), is(true));
          assertThat(predicate.test(eventWithLevel(fatal())), is(false));
      }
  
      @Test
      public void typeBasedPredicateShouldOnlyMatchEventsOfThatType() {
          // Set up
          final EventType matchingEventType = EventType.get("database");
          final EventType nonMatchingEventType = EventType.get("upgrade");
  
          // Invoke
          final Predicate<Event> predicate = EventPredicates.type(matchingEventType);
  
          // Check
          assertThat(predicate.test(eventWithType(matchingEventType)), is(true));
          assertThat(predicate.test(eventWithType(nonMatchingEventType)), is(false));
      }
  
      @Test
      public void attributeBasedPredicateWithNullValueShouldOnlyMatchEventsWithNoSuchAttribute() {
          // Invoke
          final Predicate<Event> predicate = EventPredicates.attributeEquals(ATTRIBUTE_NAME, null);
  
          // Check
          assertThat(predicate.test(eventWithAttribute(null)), is(true));
          assertThat(predicate.test(eventWithAttribute("bar")), is(false));
      }
  
      @Test
      public void attributeBasedPredicateWithNonNullValueShouldOnlyMatchEventsWithThatAttributeValue() {
          // Invoke
          final Predicate<Event> predicate = EventPredicates.attributeEquals(ATTRIBUTE_NAME, "bar");
  
          // Check
          assertThat(predicate.test(eventWithAttribute("bar")), is(true));
          assertThat(predicate.test(eventWithAttribute(null)), is(false));
      }
  }