diff --git a/BUCK b/BUCK
index 581deae..1bbb56a 100644
--- a/BUCK
+++ b/BUCK
@@ -6,9 +6,6 @@
   '//lib/guice:guice',
   '//lib/jgit:jgit',
   '//lib/log:api',
-  '//lib:grappa', # used for it's parboiled part. See
-  # core's 0db7612e092b37c6ea04883a5a45f51c6d9ae433
-  # for details
   '//lib:velocity',
 ]
 
diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/validation/ItsValidateComment.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/validation/ItsValidateComment.java
index 1db8c91..c05118a 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/validation/ItsValidateComment.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/validation/ItsValidateComment.java
@@ -27,7 +27,6 @@
 import com.googlesource.gerrit.plugins.its.base.util.IssueExtractor;
 
 import org.eclipse.jgit.revwalk.RevCommit;
-import org.eclipse.jgit.transport.ReceiveCommand;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -52,7 +51,8 @@
   @Inject
   private IssueExtractor issueExtractor;
 
-  private List<CommitValidationMessage> validCommit(ReceiveCommand cmd, RevCommit commit) throws CommitValidationException {
+  private List<CommitValidationMessage> validCommit(RevCommit commit)
+      throws CommitValidationException {
     List<CommitValidationMessage> ret = Lists.newArrayList();
     ItsAssociationPolicy associationPolicy = itsConfig.getItsAssociationPolicy();
 
@@ -144,7 +144,7 @@
   public List<CommitValidationMessage> onCommitReceived(
       CommitReceivedEvent receiveEvent) throws CommitValidationException {
     if (itsConfig.isEnabled(receiveEvent.project.getName(), receiveEvent.refName)) {
-      return validCommit(receiveEvent.command, receiveEvent.commit);
+      return validCommit(receiveEvent.commit);
     } else {
       return Collections.emptyList();
     }
diff --git a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/action/AddVelocityComment.java b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/action/AddVelocityComment.java
index d8e3b59..f3a1cc2 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/action/AddVelocityComment.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/its/base/workflow/action/AddVelocityComment.java
@@ -25,13 +25,13 @@
 import org.apache.commons.lang.StringUtils;
 import org.apache.velocity.VelocityContext;
 import org.apache.velocity.runtime.RuntimeInstance;
-import org.parboiled.common.FileUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.io.IOException;
 import java.io.StringWriter;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.Set;
@@ -105,12 +105,12 @@
       if (templateName.isEmpty()) {
         log.error("No template name given in " + actionRequest);
       } else {
-        File templateFile = new File(sitePath.toFile(), ITS_TEMPLATE_DIR +
-            File.separator + templateName + ".vm");
-        if (templateFile.canRead()) {
-          template = FileUtils.readAllText(templateFile);
+        Path templateDir = sitePath.resolve(ITS_TEMPLATE_DIR);
+        Path templatePath = templateDir.resolve(templateName + ".vm");
+        if (Files.isReadable(templatePath)) {
+          template = new String(Files.readAllBytes(templatePath));
         } else {
-          log.error("Cannot read template " + templateFile);
+          log.error("Cannot read template " + templatePath);
         }
       }
     }
diff --git a/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java b/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java
index 6be9652..6d8a5f9 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/its/base/its/ItsConfigTest.java
@@ -419,43 +419,83 @@
   }
 
   public void testIsEnabledCommentAddedEvent() {
-    testIsEnabledEvent(CommentAddedEvent.class);
+    String[] branches = {};
+    setupIsEnabled("true", null, branches);
+
+    CommentAddedEvent event = new CommentAddedEvent();
+    event.change = new ChangeAttribute();
+    event.change.project = "testProject";
+    event.change.branch = "testBranch";
+
+    ItsConfig itsConfig = createItsConfig();
+
+    replayMocks();
+
+    assertTrue(itsConfig.isEnabled(event));
   }
 
   public void testIsEnabledChangeMergedEvent() {
-    testIsEnabledEvent(ChangeMergedEvent.class);
+    String[] branches = {};
+    setupIsEnabled("true", null, branches);
+
+    ChangeMergedEvent event = new ChangeMergedEvent();
+    event.change = new ChangeAttribute();
+    event.change.project = "testProject";
+    event.change.branch = "testBranch";
+
+    ItsConfig itsConfig = createItsConfig();
+
+    replayMocks();
+
+    assertTrue(itsConfig.isEnabled(event));
   }
 
   public void testIsEnabledChangeAbandonedEvent() {
-    testIsEnabledEvent(ChangeAbandonedEvent.class);
+    String[] branches = {};
+    setupIsEnabled("true", null, branches);
+
+    ChangeAbandonedEvent event = new ChangeAbandonedEvent();
+    event.change = new ChangeAttribute();
+    event.change.project = "testProject";
+    event.change.branch = "testBranch";
+
+    ItsConfig itsConfig = createItsConfig();
+
+    replayMocks();
+
+    assertTrue(itsConfig.isEnabled(event));
   }
 
   public void testIsEnabledChangeRestoredEvent() {
-    testIsEnabledEvent(ChangeRestoredEvent.class);
+    String[] branches = {};
+    setupIsEnabled("true", null, branches);
+
+    ChangeRestoredEvent event = new ChangeRestoredEvent();
+    event.change = new ChangeAttribute();
+    event.change.project = "testProject";
+    event.change.branch = "testBranch";
+
+    ItsConfig itsConfig = createItsConfig();
+
+    replayMocks();
+
+    assertTrue(itsConfig.isEnabled(event));
   }
 
   public void testIsEnabledDraftPublishedEvent() {
-    testIsEnabledEvent(DraftPublishedEvent.class);
-  }
+    String[] branches = {};
+    setupIsEnabled("true", null, branches);
 
-  private <T extends ChangeEvent> void testIsEnabledEvent(Class<T> clazz) {
-    try {
-      String[] branches = {};
-      setupIsEnabled("true", null, branches);
+    DraftPublishedEvent event = new DraftPublishedEvent();
+    event.change = new ChangeAttribute();
+    event.change.project = "testProject";
+    event.change.branch = "testBranch";
 
-      T event = clazz.newInstance();
-      event.change = new ChangeAttribute();
-      event.change.project = "testProject";
-      event.change.branch = "testBranch";
+    ItsConfig itsConfig = createItsConfig();
 
-      ItsConfig itsConfig = createItsConfig();
+    replayMocks();
 
-      replayMocks();
-
-      assertTrue(itsConfig.isEnabled(event));
-    } catch (InstantiationException | IllegalAccessException e) {
-      throw new RuntimeException("Unable to implement event class " + clazz.getCanonicalName(), e);
-    }
+    assertTrue(itsConfig.isEnabled(event));
   }
 
   public void testIsEnabledRefUpdatedEvent() {
