gerrit-acceptance-framework/src/test/java/com/google/gerrit/acceptance/EventRecorder.java

// Copyright (C) 2016 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.acceptance;

import static com.google.common.truth.Truth.assertThat;

import com.google.common.base.Function;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
import com.google.gerrit.common.UserScopedEventListener;
import com.google.gerrit.extensions.registration.DynamicSet;
import com.google.gerrit.extensions.registration.RegistrationHandle;
import com.google.gerrit.server.CurrentUser;
import com.google.gerrit.server.IdentifiedUser;
import com.google.gerrit.server.data.RefUpdateAttribute;
import com.google.gerrit.server.events.ChangeMergedEvent;
import com.google.gerrit.server.events.Event;
import com.google.gerrit.server.events.RefEvent;
import com.google.gerrit.server.events.RefUpdatedEvent;
import com.google.gerrit.server.events.ReviewerDeletedEvent;
import com.google.inject.Inject;
import com.google.inject.Singleton;

import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.revwalk.RevCommit;

public class EventRecorder {
  private final RegistrationHandle eventListenerRegistration;
  private final Multimap<String, RefEvent> recordedEvents;

  @Singleton
  public static class Factory {
    private final DynamicSet<UserScopedEventListener> eventListeners;
    private final IdentifiedUser.GenericFactory userFactory;

    @Inject
    Factory(DynamicSet<UserScopedEventListener> eventListeners,
        IdentifiedUser.GenericFactory userFactory) {
      this.eventListeners = eventListeners;
      this.userFactory = userFactory;
    }

    public EventRecorder create(TestAccount user) {
      return new EventRecorder(eventListeners, userFactory.create(user.id));
    }
  }

  public EventRecorder(DynamicSet<UserScopedEventListener> eventListeners,
      final IdentifiedUser user) {
    recordedEvents = LinkedListMultimap.create();

    eventListenerRegistration = eventListeners.add(
        new UserScopedEventListener() {
          @Override
          public void onEvent(Event e) {
            if (e instanceof ReviewerDeletedEvent) {
              recordedEvents.put(
                  ReviewerDeletedEvent.TYPE, (ReviewerDeletedEvent) e);
            } else if (e instanceof RefEvent) {
              RefEvent event = (RefEvent) e;
              String key = refEventKey(event.getType(),
                  event.getProjectNameKey().get(),
                  event.getRefName());
              recordedEvents.put(key, event);
            }
          }

          @Override
          public CurrentUser getUser() {
            return user;
          }
        });
  }

  private static String refEventKey(String type, String project, String ref) {
    return String.format("%s-%s-%s", type, project, ref);
  }

  private static class RefEventTransformer<T extends RefEvent>
      implements Function<RefEvent, T> {

    @SuppressWarnings("unchecked")
    @Override
    public T apply(RefEvent e) {
      return (T) e;
    }
  }

  private ImmutableList<RefUpdatedEvent> getRefUpdatedEvents(String project,
      String refName, int expectedSize) {
    String key = refEventKey(RefUpdatedEvent.TYPE, project, refName);
    if (expectedSize == 0) {
      assertThat(recordedEvents).doesNotContainKey(key);
      return ImmutableList.of();
    }

    assertThat(recordedEvents).containsKey(key);
    ImmutableList<RefUpdatedEvent> events = FluentIterable
        .from(recordedEvents.get(key))
        .transform(new RefEventTransformer<RefUpdatedEvent>())
        .toList();
    assertThat(events).hasSize(expectedSize);
    return events;
  }

  private ImmutableList<ChangeMergedEvent> getChangeMergedEvents(String project,
      String branch, int expectedSize) {
    String key = refEventKey(ChangeMergedEvent.TYPE, project, branch);
    if (expectedSize == 0) {
      assertThat(recordedEvents).doesNotContainKey(key);
      return ImmutableList.of();
    }

    assertThat(recordedEvents).containsKey(key);
    ImmutableList<ChangeMergedEvent> events = FluentIterable
        .from(recordedEvents.get(key))
        .transform(new RefEventTransformer<ChangeMergedEvent>())
        .toList();
    assertThat(events).hasSize(expectedSize);
    return events;
  }

  private ImmutableList<ReviewerDeletedEvent> getReviewerDeletedEvents(
      int expectedSize) {
    String key = ReviewerDeletedEvent.TYPE;
    if (expectedSize == 0) {
      assertThat(recordedEvents).doesNotContainKey(key);
      return ImmutableList.of();
    }
    assertThat(recordedEvents).containsKey(key);
    ImmutableList<ReviewerDeletedEvent> events = FluentIterable
        .from(recordedEvents.get(key))
        .transform(new RefEventTransformer<ReviewerDeletedEvent>())
        .toList();
    assertThat(events).hasSize(expectedSize);
    return events;
  }

  public void assertRefUpdatedEvents(String project, String branch,
      String... expected) throws Exception {
    ImmutableList<RefUpdatedEvent> events = getRefUpdatedEvents(project,
        branch, expected.length / 2);
    int i = 0;
    for (RefUpdatedEvent event : events) {
      RefUpdateAttribute actual = event.refUpdate.get();
      String oldRev = expected[i] == null
          ? ObjectId.zeroId().name()
          : expected[i];
      String newRev = expected[i+1] == null
          ? ObjectId.zeroId().name()
          : expected[i+1];
      assertThat(actual.oldRev).isEqualTo(oldRev);
      assertThat(actual.newRev).isEqualTo(newRev);
      i += 2;
    }
  }

  public void assertRefUpdatedEvents(String project, String branch,
      RevCommit... expected) throws Exception {
    ImmutableList<RefUpdatedEvent> events = getRefUpdatedEvents(project,
        branch, expected.length / 2);
    int i = 0;
    for (RefUpdatedEvent event : events) {
      RefUpdateAttribute actual = event.refUpdate.get();
      String oldRev = expected[i] == null
          ? ObjectId.zeroId().name()
          : expected[i].name();
      String newRev = expected[i+1] == null
          ? ObjectId.zeroId().name()
          : expected[i+1].name();
      assertThat(actual.oldRev).isEqualTo(oldRev);
      assertThat(actual.newRev).isEqualTo(newRev);
      i += 2;
    }
  }

  public void assertChangeMergedEvents(String project, String branch,
      String... expected) throws Exception {
    ImmutableList<ChangeMergedEvent> events = getChangeMergedEvents(project,
        branch, expected.length / 2);
    int i = 0;
    for (ChangeMergedEvent event : events) {
      String id = event.change.get().id;
      assertThat(id).isEqualTo(expected[i]);
      assertThat(event.newRev).isEqualTo(expected[i+1]);
      i += 2;
    }
  }

  public void assertReviewerDeletedEvents(String... expected) {
    ImmutableList<ReviewerDeletedEvent> events =
        getReviewerDeletedEvents(expected.length / 2);
    int i = 0;
    for (ReviewerDeletedEvent event : events) {
      String id = event.change.get().id;
      assertThat(id).isEqualTo(expected[i]);
      String reviewer = event.reviewer.get().email;
      assertThat(reviewer).isEqualTo(expected[i+1]);
      i += 2;
    }
  }

  public void close() {
    eventListenerRegistration.remove();
  }
}