diff --git a/BUILD b/BUILD
index 24a2d60..5077015 100644
--- a/BUILD
+++ b/BUILD
@@ -20,18 +20,37 @@
 
 junit_tests(
     name = "healthcheck_tests",
-    srcs = glob(["src/test/java/**/*.java"]),
+    srcs = glob(
+        [
+            "src/test/java/**/*Test.java",
+        ],
+        exclude = ["src/test/java/**/Abstract*.java"],
+    ),
     resources = glob(["src/test/resources/**/*"]),
     deps = [
         ":healthcheck__plugin_test_deps",
     ],
 )
 
+[junit_tests(
+    name = f[:f.index(".")].replace("/", "_"),
+    srcs = [f],
+    tags = ["owners"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":healthcheck__plugin_test_deps",
+    ],
+) for f in glob(["src/test/java/**/*IT.java"])]
+
 java_library(
     name = "healthcheck__plugin_test_deps",
     testonly = 1,
+    srcs = glob(["src/test/java/**/Abstract*.java"]),
     visibility = ["//visibility:public"],
     exports = PLUGIN_DEPS + PLUGIN_TEST_DEPS + [
         ":healthcheck__plugin",
     ],
+    deps = PLUGIN_DEPS + PLUGIN_TEST_DEPS + [
+        ":healthcheck__plugin",
+    ],
 )
diff --git a/src/main/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckSubsystemsModule.java b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckSubsystemsModule.java
index aea007a..bff5c13 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckSubsystemsModule.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckSubsystemsModule.java
@@ -16,9 +16,11 @@
 
 import com.google.gerrit.extensions.config.FactoryModule;
 import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.server.index.OnlineUpgradeListener;
 import com.googlesource.gerrit.plugins.healthcheck.check.ActiveWorkersCheck;
 import com.googlesource.gerrit.plugins.healthcheck.check.AuthHealthCheck;
 import com.googlesource.gerrit.plugins.healthcheck.check.BlockedThreadsCheck;
+import com.googlesource.gerrit.plugins.healthcheck.check.ChangesIndexHealthCheck;
 import com.googlesource.gerrit.plugins.healthcheck.check.DeadlockCheck;
 import com.googlesource.gerrit.plugins.healthcheck.check.HealthCheck;
 import com.googlesource.gerrit.plugins.healthcheck.check.JGitHealthCheck;
@@ -36,6 +38,9 @@
     bindChecker(ActiveWorkersCheck.class);
     bindChecker(DeadlockCheck.class);
     bindChecker(BlockedThreadsCheck.class);
+    bindChecker(ChangesIndexHealthCheck.class);
+
+    DynamicSet.bind(binder(), OnlineUpgradeListener.class).to(ChangesIndexHealthCheck.class);
 
     install(BlockedThreadsCheck.SUB_CHECKS);
   }
diff --git a/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/ChangesIndexHealthCheck.java b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/ChangesIndexHealthCheck.java
new file mode 100644
index 0000000..fada9aa
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/ChangesIndexHealthCheck.java
@@ -0,0 +1,159 @@
+// Copyright (C) 2023 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.googlesource.gerrit.plugins.healthcheck.check;
+
+import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.CHANGES_INDEX;
+
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.gerrit.index.IndexType;
+import com.google.gerrit.metrics.MetricMaker;
+import com.google.gerrit.server.config.GerritServerConfig;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.gerrit.server.index.OnlineUpgradeListener;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import com.googlesource.gerrit.plugins.healthcheck.HealthCheckConfig;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.storage.file.FileBasedConfig;
+import org.eclipse.jgit.util.FS;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Singleton
+public class ChangesIndexHealthCheck extends AbstractHealthCheck implements OnlineUpgradeListener {
+  private static final Logger log = LoggerFactory.getLogger(QueryChangesHealthCheck.class);
+  private static final String lockFilename = "write.lock";
+
+  private final SitePaths sitePaths;
+  private final boolean isLuceneIndex;
+  private final AtomicReference<Optional<ChangesIndexLockFiles>> changes;
+
+  @Inject
+  ChangesIndexHealthCheck(
+      @GerritServerConfig Config cfg,
+      ListeningExecutorService executor,
+      HealthCheckConfig config,
+      MetricMaker metricMaker,
+      SitePaths sitePaths) {
+    super(executor, config, CHANGES_INDEX, metricMaker);
+    this.sitePaths = sitePaths;
+    this.isLuceneIndex = isIndexTypeLucene(cfg);
+    this.changes = new AtomicReference<>(getChangesIndexLockFiles(sitePaths.index_dir));
+  }
+
+  @Override
+  protected Result doCheck() throws Exception {
+    return isLuceneIndex
+        ? changes
+            .get()
+            .map(locks -> locks.valid() ? Result.PASSED : Result.FAILED)
+            .orElse(Result.FAILED)
+        : Result.DISABLED;
+  }
+
+  @Override
+  public void onStart(String name, int oldVersion, int newVersion) {}
+
+  @Override
+  public void onSuccess(String name, int oldVersion, int newVersion) {
+    if (!isLuceneIndex || !name.equals("changes") || oldVersion == newVersion) {
+      return;
+    }
+
+    Optional<ChangesIndexLockFiles> newLockFiles =
+        Optional.of(
+            getChangesLockFiles(sitePaths.index_dir, String.format("changes_%04d", newVersion)));
+    if (!changes.compareAndSet(changes.get(), newLockFiles)) {
+      log.info(
+          "New version {} of changes index healthcheck lock files was set already by another thread",
+          newVersion);
+    } else {
+      log.info(
+          "Changes index healthcheck switched from index version {} to {}", oldVersion, newVersion);
+    }
+  }
+
+  @Override
+  public void onFailure(String name, int oldVersion, int newVersion) {}
+
+  private static boolean isIndexTypeLucene(Config cfg) {
+    IndexType indexType = new IndexType(cfg.getString("index", null, "type"));
+    boolean isLucene = indexType.isLucene();
+    if (!isLucene) {
+      log.warn(
+          "Configured index type [{}] is not supported for index health check therefore it is disabled.",
+          indexType);
+    }
+    return isLucene;
+  }
+
+  private Optional<ChangesIndexLockFiles> getChangesIndexLockFiles(Path indexDir) {
+    if (!isLuceneIndex) {
+      Optional.empty();
+    }
+
+    FileBasedConfig cfg =
+        new FileBasedConfig(indexDir.resolve("gerrit_index.config").toFile(), FS.detect());
+    try {
+      cfg.load();
+      return getActiveIndexVersion(cfg, "changes")
+          .map(version -> getChangesLockFiles(indexDir, version));
+    } catch (IOException | ConfigInvalidException e) {
+      log.error("Getting changes index version from configuration failed", e);
+    }
+    return Optional.empty();
+  }
+
+  private static Optional<String> getActiveIndexVersion(Config cfg, String indexPrefix) {
+    String section = "index";
+    return cfg.getSubsections(section).stream()
+        .filter(
+            subsection ->
+                subsection.startsWith(indexPrefix)
+                    && cfg.getBoolean(section, subsection, "ready", false))
+        .findAny();
+  }
+
+  private ChangesIndexLockFiles getChangesLockFiles(Path indexDir, String indexVersion) {
+    Path versionDir = indexDir.resolve(indexVersion);
+    return new ChangesIndexLockFiles(
+        versionDir.resolve("open").resolve(lockFilename).toFile(),
+        versionDir.resolve("closed").resolve(lockFilename).toFile());
+  }
+
+  private static class ChangesIndexLockFiles {
+    private final File openLock;
+    private final File closedLock;
+
+    private ChangesIndexLockFiles(File openLock, File closedLock) {
+      this.openLock = openLock;
+      this.closedLock = closedLock;
+    }
+
+    private boolean valid() {
+      return validLock(openLock) && validLock(closedLock);
+    }
+
+    private static boolean validLock(File writeLock) {
+      return writeLock.isFile() && writeLock.canWrite();
+    }
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/HealthCheckNames.java b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/HealthCheckNames.java
index 4771942..5a4947f 100644
--- a/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/HealthCheckNames.java
+++ b/src/main/java/com/googlesource/gerrit/plugins/healthcheck/check/HealthCheckNames.java
@@ -23,4 +23,5 @@
   String DEADLOCK = "deadlock";
   String BLOCKEDTHREADS = "blockedthreads";
   String GLOBAL = "global";
+  String CHANGES_INDEX = "changesindex";
 }
diff --git a/src/main/resources/Documentation/config.md b/src/main/resources/Documentation/config.md
index 0b4f05f..7f7d549 100644
--- a/src/main/resources/Documentation/config.md
+++ b/src/main/resources/Documentation/config.md
@@ -56,6 +56,8 @@
 - `activeworkers`: check the number of active worker threads and the ability to create a new one
 - `deadlock` : check if Java deadlocks are reported by the JVM
 - `blockedthreads` : check the number of blocked threads
+- `changesindex` : check if the lucene based changes indexes (open and closed) are operable
+   (examines index lock files)
 
 Each check name can be disabled by setting the `enabled` parameter to **false**,
 by default this parameter is set to **true**
diff --git a/src/main/resources/Documentation/metrics.md b/src/main/resources/Documentation/metrics.md
index 76e6eb5..f250d1b 100644
--- a/src/main/resources/Documentation/metrics.md
+++ b/src/main/resources/Documentation/metrics.md
@@ -52,6 +52,10 @@
 # TYPE plugins_healthcheck_blockedthreads_latest_measured_latency gauge
 plugins_healthcheck_blockedthreads_latest_measured_latency 6.0
 
+# HELP plugins_healthcheck_changesindex_latest_measured_latency Generated from Dropwizard metric import (metric=plugins/healthcheck/changesindex/latency, type=com.google.gerrit.metrics.dropwizard.CallbackMetricImpl0$1)
+# TYPE plugins_healthcheck_changesindex_latest_measured_latency gauge
+plugins_healthcheck_changesindex_latest_measured_latency 3.0
+
 # HELP plugins_healthcheck_jgit_failure_total Generated from Dropwizard metric import (metric=plugins/healthcheck/jgit/failure, type=com.codahale.metrics.Meter)
 # TYPE plugins_healthcheck_jgit_failure_total counter
 plugins_healthcheck_jgit_failure_total 3.0
@@ -63,6 +67,10 @@
 # HELP plugins_healthcheck_blockedthreads_failure_total Generated from Dropwizard metric import (metric=plugins/healthcheck/blockedthreads/failure, type=com.codahale.metrics.Meter)
 # TYPE plugins_healthcheck_blockedthreads_failure_total counter
 plugins_healthcheck_blockedthreads_failure_total 1.0
+
+# HELP plugins_healthcheck_changesindex_failure_total Generated from Dropwizard metric import (metric=plugins/healthcheck/changesindex/failure, type=com.codahale.metrics.Meter)
+# TYPE plugins_healthcheck_changesindex_failure_total counter
+plugins_healthcheck_changesindex_failure_total 1.0
 ```
 
 Note that additionally to the default `blockedthreads` metrics pair failures counter will reported for
diff --git a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/AbstractHealthCheckIntegrationTest.java b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/AbstractHealthCheckIntegrationTest.java
new file mode 100644
index 0000000..ff924e6
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/AbstractHealthCheckIntegrationTest.java
@@ -0,0 +1,85 @@
+// Copyright (C) 2023 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.googlesource.gerrit.plugins.healthcheck;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.gerrit.acceptance.LightweightPluginDaemonTest;
+import com.google.gerrit.acceptance.RestResponse;
+import com.google.gerrit.extensions.annotations.PluginName;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.inject.AbstractModule;
+import com.google.inject.Key;
+import com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames;
+import java.io.IOException;
+import org.eclipse.jgit.errors.ConfigInvalidException;
+
+class AbstractHealthCheckIntegrationTest extends LightweightPluginDaemonTest {
+  public static class TestModule extends AbstractModule {
+
+    @Override
+    protected void configure() {
+      install(new HealthCheckExtensionApiModule());
+      install(new Module());
+    }
+  }
+
+  protected HealthCheckConfig config;
+  protected String healthCheckUriPath;
+
+  private final Gson gson = new Gson();
+
+  @Override
+  public void setUpTestPlugin() throws Exception {
+    super.setUpTestPlugin();
+
+    config = plugin.getSysInjector().getInstance(HealthCheckConfig.class);
+
+    int numChanges = config.getLimit(HealthCheckNames.QUERYCHANGES);
+    for (int i = 0; i < numChanges; i++) {
+      createChange("refs/for/master");
+    }
+    accountCreator.create(config.getUsername(HealthCheckNames.AUTH));
+
+    healthCheckUriPath =
+        String.format(
+            "/config/server/%s~status",
+            plugin.getSysInjector().getInstance(Key.get(String.class, PluginName.class)));
+  }
+
+  protected RestResponse getHealthCheckStatus() throws IOException {
+    return adminRestSession.get(healthCheckUriPath);
+  }
+
+  protected RestResponse getHealthCheckStatusAnonymously() throws IOException {
+    return anonymousRestSession.get(healthCheckUriPath);
+  }
+
+  protected void assertCheckResult(JsonObject respPayload, String checkName, String result) {
+    assertThat(respPayload.has(checkName)).isTrue();
+    JsonObject reviewDbStatus = respPayload.get(checkName).getAsJsonObject();
+    assertThat(reviewDbStatus.has("result")).isTrue();
+    assertThat(reviewDbStatus.get("result").getAsString()).isEqualTo(result);
+  }
+
+  protected void disableCheck(String check) throws ConfigInvalidException {
+    config.fromText(String.format("[healthcheck \"%s\"]\n" + "enabled = false", check));
+  }
+
+  protected JsonObject getResponseJson(RestResponse resp) throws IOException {
+    return gson.fromJson(resp.getReader(), JsonObject.class);
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ChangesIndexHealthCheckIT.java b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ChangesIndexHealthCheckIT.java
new file mode 100644
index 0000000..33d3277
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ChangesIndexHealthCheckIT.java
@@ -0,0 +1,120 @@
+// Copyright (C) 2023 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.googlesource.gerrit.plugins.healthcheck;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.CHANGES_INDEX;
+
+import com.google.gerrit.acceptance.RestResponse;
+import com.google.gerrit.acceptance.Sandboxed;
+import com.google.gerrit.acceptance.TestPlugin;
+import com.google.gerrit.acceptance.UseLocalDisk;
+import com.google.gerrit.acceptance.config.GerritConfig;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.inject.Inject;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Iterator;
+import javax.servlet.http.HttpServletResponse;
+import org.junit.Test;
+
+@TestPlugin(
+    name = "healthcheck-test",
+    sysModule =
+        "com.googlesource.gerrit.plugins.healthcheck.AbstractHealthCheckIntegrationTest$TestModule",
+    httpModule = "com.googlesource.gerrit.plugins.healthcheck.HttpModule")
+@Sandboxed
+public class ChangesIndexHealthCheckIT extends AbstractHealthCheckIntegrationTest {
+  @Inject SitePaths sitePaths;
+
+  @Test
+  @UseLocalDisk
+  @GerritConfig(name = "index.type", value = "lucene")
+  public void shouldReturnChangesIndexCheck() throws Exception {
+    RestResponse resp = getHealthCheckStatus();
+    resp.assertOK();
+
+    assertCheckResult(getResponseJson(resp), CHANGES_INDEX, "passed");
+  }
+
+  @Test
+  @UseLocalDisk
+  @GerritConfig(name = "index.type", value = "lucene")
+  public void shouldFailWhenOpenChangesIndexWriteLockIsMissing() throws Exception {
+    shouldFailWhenChangesIndexWriteLockIsMissing("open");
+  }
+
+  @Test
+  @UseLocalDisk
+  @GerritConfig(name = "index.type", value = "lucene")
+  public void shouldFailWhenClosedChangesIndexWriteLockIsMissing() throws Exception {
+    shouldFailWhenChangesIndexWriteLockIsMissing("closed");
+  }
+
+  private void shouldFailWhenChangesIndexWriteLockIsMissing(String indexType) throws Exception {
+    RestResponse resp = getHealthCheckStatus();
+    resp.assertOK();
+
+    assertCheckResult(getResponseJson(resp), CHANGES_INDEX, "passed");
+
+    Path openChangesIndexLockPath = getIndexLockFile(sitePaths.index_dir, indexType);
+    assertThat(
+            openChangesIndexLockPath
+                .toFile()
+                .renameTo(
+                    openChangesIndexLockPath
+                        .getParent()
+                        .resolve(openChangesIndexLockPath.getFileName().toString() + ".backup")
+                        .toFile()))
+        .isTrue();
+
+    resp = getHealthCheckStatus();
+    resp.assertStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+
+    assertCheckResult(getResponseJson(resp), CHANGES_INDEX, "failed");
+  }
+
+  @Test
+  @GerritConfig(name = "index.type", value = "lucene")
+  public void shouldReturnChangesIndexCheckAsDisabled() throws Exception {
+    disableCheck(CHANGES_INDEX);
+    RestResponse resp = getHealthCheckStatus();
+
+    resp.assertOK();
+    assertCheckResult(getResponseJson(resp), CHANGES_INDEX, "disabled");
+  }
+
+  @Test
+  @GerritConfig(name = "index.type", value = "fake")
+  public void shouldReturnChangesIndexCheckAsDisabledWhenIndexIsNotLucene() throws Exception {
+    RestResponse resp = getHealthCheckStatus();
+
+    resp.assertOK();
+    assertCheckResult(getResponseJson(resp), CHANGES_INDEX, "disabled");
+  }
+
+  private Path getIndexLockFile(Path indexDir, String indexType) throws IOException {
+    try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(indexDir, "changes_*")) {
+      Iterator<Path> changesDir = dirStream.iterator();
+      if (changesDir.hasNext()) {
+        return changesDir.next().resolve(indexType).resolve("write.lock");
+      }
+      throw new RuntimeException(
+          String.format("there is no `changes_*` dir under [%s] index dir", indexDir));
+    }
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckIT.java b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckIT.java
index 17f1e10..a0c9885 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckIT.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/HealthCheckIT.java
@@ -18,20 +18,15 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.ACTIVEWORKERS;
 import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.AUTH;
+import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.CHANGES_INDEX;
 import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.JGIT;
 import static com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames.QUERYCHANGES;
 
-import com.google.gerrit.acceptance.LightweightPluginDaemonTest;
 import com.google.gerrit.acceptance.RestResponse;
 import com.google.gerrit.acceptance.Sandboxed;
 import com.google.gerrit.acceptance.TestPlugin;
 import com.google.gerrit.acceptance.config.GerritConfig;
-import com.google.gerrit.extensions.annotations.PluginName;
-import com.google.gson.Gson;
 import com.google.gson.JsonObject;
-import com.google.inject.AbstractModule;
-import com.google.inject.Key;
-import com.googlesource.gerrit.plugins.healthcheck.check.HealthCheckNames;
 import java.io.File;
 import java.io.IOException;
 import javax.servlet.http.HttpServletResponse;
@@ -41,43 +36,24 @@
 
 @TestPlugin(
     name = "healthcheck-test",
-    sysModule = "com.googlesource.gerrit.plugins.healthcheck.HealthCheckIT$TestModule",
+    sysModule =
+        "com.googlesource.gerrit.plugins.healthcheck.AbstractHealthCheckIntegrationTest$TestModule",
     httpModule = "com.googlesource.gerrit.plugins.healthcheck.HttpModule")
 @Sandboxed
-public class HealthCheckIT extends LightweightPluginDaemonTest {
-  Gson gson = new Gson();
-  HealthCheckConfig config;
-  String healthCheckUriPath;
-  String failFilePath;
-
-  public static class TestModule extends AbstractModule {
-
-    @Override
-    protected void configure() {
-      install(new HealthCheckExtensionApiModule());
-      install(new Module());
-    }
-  }
+public class HealthCheckIT extends AbstractHealthCheckIntegrationTest {
+  private String failFilePath = "/tmp/fail";
 
   @Override
   @Before
   public void setUpTestPlugin() throws Exception {
     super.setUpTestPlugin();
 
-    config = plugin.getSysInjector().getInstance(HealthCheckConfig.class);
-    failFilePath = "/tmp/fail";
     new File(failFilePath).delete();
 
-    int numChanges = config.getLimit(HealthCheckNames.QUERYCHANGES);
-    for (int i = 0; i < numChanges; i++) {
-      createChange("refs/for/master");
-    }
-    accountCreator.create(config.getUsername(HealthCheckNames.AUTH));
-
-    healthCheckUriPath =
-        String.format(
-            "/config/server/%s~status",
-            plugin.getSysInjector().getInstance(Key.get(String.class, PluginName.class)));
+    // disable `changesindex` check as it requires @UseLocalDisk annotation (so that all operations
+    // are persisted to local FS) to be applied and that would degrade this IT performance - see
+    // ChangesIndexHealthCheckIT for a changes index dedicated integration tests
+    super.disableCheck(CHANGES_INDEX);
   }
 
   @Test
@@ -224,37 +200,23 @@
     assertThat(respBody.get("reason").getAsString()).isEqualTo("Fail Flag File exists");
   }
 
+  @Override
+  protected void disableCheck(String check) throws ConfigInvalidException {
+    // additionally disable `changesindex` healthcheck as it requires @UseLocalDisk annotation to
+    // run properly
+    config.fromText(
+        String.format(
+            "[healthcheck \"%s\"]\n enabled = false\n[healthcheck \"%s\"]\n enabled = false",
+            check, CHANGES_INDEX));
+  }
+
   private void createFailFileFlag(String path) throws IOException {
     File file = new File(path);
     file.createNewFile();
     file.deleteOnExit();
   }
 
-  private RestResponse getHealthCheckStatus() throws IOException {
-    return adminRestSession.get(healthCheckUriPath);
-  }
-
-  private RestResponse getHealthCheckStatusAnonymously() throws IOException {
-    return anonymousRestSession.get(healthCheckUriPath);
-  }
-
-  private void assertCheckResult(JsonObject respPayload, String checkName, String result) {
-    assertThat(respPayload.has(checkName)).isTrue();
-    JsonObject reviewDbStatus = respPayload.get(checkName).getAsJsonObject();
-    assertThat(reviewDbStatus.has("result")).isTrue();
-    assertThat(reviewDbStatus.get("result").getAsString()).isEqualTo(result);
-  }
-
-  private void disableCheck(String check) throws ConfigInvalidException {
-    config.fromText(String.format("[healthcheck \"%s\"]\n" + "enabled = false", check));
-  }
-
   private void setFailFlagFilePath(String path) throws ConfigInvalidException {
     config.fromText(String.format("[healthcheck]\n" + "failFileFlagPath = %s", path));
   }
-
-  private JsonObject getResponseJson(RestResponse resp) throws IOException {
-    JsonObject respPayload = gson.fromJson(resp.getReader(), JsonObject.class);
-    return respPayload;
-  }
 }
diff --git a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ProjectsListHealthCheckTest.java b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ProjectsListHealthCheckTest.java
index 610284c..293c596 100644
--- a/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ProjectsListHealthCheckTest.java
+++ b/src/test/java/com/googlesource/gerrit/plugins/healthcheck/ProjectsListHealthCheckTest.java
@@ -85,7 +85,8 @@
 
   private Provider<ListProjects> getFailingProjectList() {
     return Providers.of(
-        new ListProjectsImpl(null, null, null, null, null, null, null, null, null, gerritConfig, null) {
+        new ListProjectsImpl(
+            null, null, null, null, null, null, null, null, null, gerritConfig, null) {
 
           @Override
           public SortedMap<String, ProjectInfo> apply() throws BadRequestException {
@@ -96,7 +97,8 @@
 
   private Provider<ListProjects> getWorkingProjectList(long execTime) {
     return Providers.of(
-        new ListProjectsImpl(null, null, null, null, null, null, null, null, null, gerritConfig, null) {
+        new ListProjectsImpl(
+            null, null, null, null, null, null, null, null, null, gerritConfig, null) {
 
           @Override
           public SortedMap<String, ProjectInfo> apply() throws BadRequestException {