AMBARI-21677 - Upgrade Pre-Checks Should Take PATCH/SERVICE Types Into Account (jonathanhurley)

ambari-server/src/main/java/org/apache/ambari/server/checks/AbstractCheckDescriptor.java

@@ -17,13 +17,12 @@
  */
 package org.apache.ambari.server.checks;
 
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import org.apache.ambari.annotations.Experimental;
-import org.apache.ambari.annotations.ExperimentalFeature;
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.api.services.AmbariMetaInfo;
 import org.apache.ambari.server.configuration.Configuration;
@@ -36,19 +35,20 @@ import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
-import org.apache.ambari.server.state.RepositoryType;
-import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.ServiceInfo;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
+import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrereqCheckType;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack;
 import org.apache.ambari.server.state.stack.upgrade.RepositoryVersionHelper;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
-import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.Lists;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 
@@ -62,7 +62,7 @@ public abstract class AbstractCheckDescriptor {
   protected static final String DEFAULT = "default";
 
   @Inject
-  Provider<Clusters> clustersProvider;
+  protected Provider<Clusters> clustersProvider;
 
   @Inject
   Provider<HostVersionDAO> hostVersionDaoProvider;
@@ -94,75 +94,54 @@ public abstract class AbstractCheckDescriptor {
   }
 
   /**
-   * Tests if the prerequisite check is applicable to given cluster. This
-   * method's default logic is to ensure that the cluster stack source and
-   * target are compatible with the prerequisite check. When overridding this
-   * method, call {@code super#isApplicable(PrereqCheckRequest)}.
+   * Gets the set of services that this check is associated with. If the check
+   * is not associated with a particular service, then this should be an empty
+   * set.
    *
-   * @param request
-   *          prerequisite check request
-   * @return true if check should be performed
+   * @return a set of services which will determine whether this check is
+   *         applicable.
+   */
+  public Set<String> getApplicableServices() {
+    return Collections.emptySet();
+  }
+
+  /**
+   * Gets any additional qualifications which an upgrade check should run in
+   * order to determine if it's applicable to the upgrade.
    *
-   * @throws org.apache.ambari.server.AmbariException
-   *           if server error happens
+   * @return a list of qualifications, or an empty list.
    */
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    // this is default behaviour
-   return true;
+  public List<CheckQualification> getQualifications() {
+    return Collections.emptyList();
   }
 
   /**
-   * Same like {@code isApplicable(PrereqCheckRequest request)}, but with service presence check
+   * Tests if the prerequisite check is applicable to given upgrade request. If
+   * a check requires some extra processing
+   *
    * @param request
    *          prerequisite check request
-   * @param requiredServices
-   *          set of services, which need to be present to allow check execution
-   * @param requiredAll
-   *          require all services in the list or at least one need to present
    * @return true if check should be performed
+   *
    * @throws org.apache.ambari.server.AmbariException
    *           if server error happens
    */
-  @Experimental(feature = ExperimentalFeature.PATCH_UPGRADES)
-  public boolean isApplicable(PrereqCheckRequest request, List<String> requiredServices, boolean requiredAll) throws AmbariException {
-    final Cluster cluster = clustersProvider.get().getCluster(request.getClusterName());
-    Set<String> services = cluster.getServices().keySet();
-
-    // default return value depends on assign inside check block
-    boolean serviceFound = requiredAll && !requiredServices.isEmpty();
-
-    for (String service : requiredServices) {
-      if ( services.contains(service) && !requiredAll) {
-        serviceFound = true;
-        break;
-      } else if (!services.contains(service) && requiredAll) {
-        serviceFound = false;
-        break;
-      }
-    }
-
-    // !!! service is found and deployed - now check if it is part of the VDF
-    if (serviceFound && null != request.getTargetStackId()) {
-      String stackName = request.getTargetStackId().getStackName();
-      RepositoryVersionEntity rve = repositoryVersionDaoProvider.get().
-          findByStackNameAndVersion(stackName, request.getTargetVersion());
-
-      if (RepositoryType.STANDARD != rve.getType()) {
-        try {
-          Set<String> availableServices = rve.getRepositoryXml().getAvailableServiceNames();
-
-          if (!CollectionUtils.containsAny(availableServices, requiredServices)) {
-            serviceFound = false;
-          }
-        } catch (Exception e) {
-          LOG.warn("Could not parse xml for %s", request.getTargetVersion(), e);
-        }
+  public final boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
+    List<CheckQualification> qualifications = Lists.<CheckQualification> newArrayList(
+        new ServiceQualification());
+
+    // add any others from the concrete check
+    qualifications.addAll(getQualifications());
+    for (CheckQualification qualification : qualifications) {
+      if (!qualification.isApplicable(request)) {
+        return false;
       }
     }
 
-    return serviceFound;
+    return true;
   }
 
+
   /**
    * Executes check against given cluster.
    *
@@ -198,7 +177,8 @@ public abstract class AbstractCheckDescriptor {
    * @param request           the request
    * @return the failure string
    */
-  protected String getFailReason(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) {
+  protected String getFailReason(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+      throws AmbariException {
     return getFailReason(DEFAULT, prerequisiteCheck, request);
   }
 
@@ -233,15 +213,6 @@ public abstract class AbstractCheckDescriptor {
     return properties.get(propertyName);
   }
 
-  protected Cluster getCluster(PrereqCheckRequest request) throws AmbariException {
-    String clusterName = request.getClusterName();
-    if (null != clusterName) {
-      return clustersProvider.get().getCluster(clusterName);
-    }
-
-    return null;
-  }
-
   /**
    * Gets the fail reason
    * @param key               the failure text key
@@ -249,12 +220,13 @@ public abstract class AbstractCheckDescriptor {
    * @param request           the request
    * @return the failure string
    */
-  protected String getFailReason(String key,
-      PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) {
+  protected String getFailReason(String key, PrerequisiteCheck prerequisiteCheck,
+      PrereqCheckRequest request) throws AmbariException {
     String fail = m_description.getFail(key);
 
-    if (fail.contains("{{version}}") && null != request.getTargetVersion()) {
-      fail = fail.replace("{{version}}", request.getTargetVersion());
+    RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+    if (fail.contains("{{version}}") && null != repositoryVersion) {
+      fail = fail.replace("{{version}}", repositoryVersion.getVersion());
     }
 
     if (fail.contains("{{fails}}")) {
@@ -265,26 +237,21 @@ public abstract class AbstractCheckDescriptor {
         Clusters clusters = clustersProvider.get();
         AmbariMetaInfo metaInfo = ambariMetaInfo.get();
 
-        try {
-          Cluster c = clusters.getCluster(request.getClusterName());
-
-          LinkedHashSet<String> displays = new LinkedHashSet<>();
-
-          for (Service service : c.getServices().values()) {
-            if (names.contains(service.getName())) {
-              try {
-                ServiceInfo serviceInfo = metaInfo.getService(service);
-                displays.add(serviceInfo.getDisplayName());
-              } catch (Exception e) {
-                displays.add(service.getName());
-              }
-            }
+        Cluster c = clusters.getCluster(request.getClusterName());
+        Map<String, ServiceInfo> services = metaInfo.getServices(
+            c.getDesiredStackVersion().getStackName(),
+            c.getDesiredStackVersion().getStackVersion());
+
+        LinkedHashSet<String> displays = new LinkedHashSet<>();
+        for (String name : names) {
+          if (services.containsKey(name)) {
+            displays.add(services.get(name).getDisplayName());
+          } else {
+            displays.add(name);
           }
-          names = displays;
-
-        } catch (Exception e) {
-          LOG.warn("Could not load service info map");
         }
+        names = displays;
+
       }
 
       fail = fail.replace("{{fails}}", formatEntityList(names));
@@ -293,7 +260,6 @@ public abstract class AbstractCheckDescriptor {
     return fail;
   }
 
-
   /**
    * Formats lists of given entities to human readable form:
    * [entity1] -> {entity1} {noun}
@@ -335,4 +301,106 @@ public abstract class AbstractCheckDescriptor {
     return false;
   }
 
-}
+  /**
+   * Gets the services participating in the upgrade from the VDF.
+   *
+   * @param request
+   *          the upgrade check request.
+   * @return the services participating in the upgrade, which can either be all
+   *         of the cluster's services or a subset based on repository type.
+   */
+  final Set<String> getServicesInUpgrade(PrereqCheckRequest request) throws AmbariException {
+    final Cluster cluster = clustersProvider.get().getCluster(request.getClusterName());
+    RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+
+    // the check is scoped to some services, so determine if any of those
+    // services are included in this upgrade
+    try {
+      VersionDefinitionXml vdf = repositoryVersion.getRepositoryXml();
+      ClusterVersionSummary clusterVersionSummary = vdf.getClusterSummary(cluster);
+      return clusterVersionSummary.getAvailableServiceNames();
+    } catch (Exception exception) {
+      throw new AmbariException("Unable to run upgrade checks because of an invalid VDF",
+          exception);
+    }
+  }
+
+  /**
+   * The {@link CheckQualification} interface is used to provide multiple
+   * different qualifications against which an upgrade check is determined to be
+   * applicable to the upgrade.
+   */
+  interface CheckQualification {
+
+    /**
+     * Gets whether the upgrade check meets this qualification and should
+     * therefore be run before the upgrade.
+     *
+     * @param request
+     * @return
+     * @throws AmbariException
+     */
+    boolean isApplicable(PrereqCheckRequest request) throws AmbariException;
+  }
+
+  /**
+   * The {@link ServiceQualification} class is used to determine if the
+   * service(s) associated with an upgraade check are both installed in the
+   * cluster and included in thr upgrade.
+   * <p/>
+   * If a service is installed but not included in the upgrade (for example of
+   * the upgrade is a patch upgrade), then the check should not qualify to run.
+   */
+  final class ServiceQualification implements CheckQualification {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
+
+      Set<String> applicableServices = getApplicableServices();
+
+      // if the check is not scoped to any particular service, then it passes
+      // this qualification
+      if (applicableServices.isEmpty()) {
+        return true;
+      }
+
+      Set<String> servicesForUpgrade = getServicesInUpgrade(request);
+
+      for (String serviceInUpgrade : servicesForUpgrade) {
+        if (applicableServices.contains(serviceInUpgrade)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+  }
+
+  /**
+   * The {@link PriorCheckQualification} class is used to determine if a prior check has run.
+   */
+  final class PriorCheckQualification implements CheckQualification {
+
+    private final CheckDescription m_checkDescription;
+
+    public PriorCheckQualification(CheckDescription checkDescription) {
+      m_checkDescription = checkDescription;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
+      PrereqCheckStatus checkStatus = request.getResult(m_checkDescription);
+      if (null != checkStatus && checkStatus == PrereqCheckStatus.FAIL) {
+        return false;
+      }
+
+      return true;
+    }
+  }
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/AtlasPresenceCheck.java

@@ -17,15 +17,14 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -36,16 +35,18 @@ import com.google.inject.Singleton;
 @UpgradeCheck(group = UpgradeCheckGroup.DEFAULT)
 public class AtlasPresenceCheck extends AbstractCheckDescriptor{
 
-  private static final Logger LOG = LoggerFactory.getLogger(AtlasPresenceCheck.class);
   private static final String serviceName = "ATLAS";
 
   public AtlasPresenceCheck(){
     super(CheckDescription.ATLAS_SERVICE_PRESENCE_CHECK);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList(serviceName), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet(serviceName);
   }
 
   @Override

ambari-server/src/main/java/org/apache/ambari/server/checks/AutoStartDisabledCheck.java

@@ -17,6 +17,9 @@
  */
 package org.apache.ambari.server.checks;
 
+import java.util.Collections;
+import java.util.Set;
+
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
@@ -48,6 +51,14 @@ public class AutoStartDisabledCheck extends AbstractCheckDescriptor {
     super(CheckDescription.AUTO_START_DISABLED);
   }
 
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public Set<String> getApplicableServices() {
+    return Collections.emptySet();
+  }
+
   /**
    * {@inheritDoc}
    */

ambari-server/src/main/java/org/apache/ambari/server/checks/CheckDescription.java

@@ -1,4 +1,4 @@
-/*
+/**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
@@ -86,9 +86,7 @@ public class CheckDescription {
     "All hosts should have target version installed",
     new ImmutableMap.Builder<String, String>()
       .put(AbstractCheckDescriptor.DEFAULT,
-          "The following hosts must have version {{version}} installed: {{fails}}.")
-      .put(HostsRepositoryVersionCheck.KEY_NO_REPO_VERSION,
-          "Repository version {{version}} does not exist.").build());
+          "The following hosts must have version {{version}} installed: {{fails}}.").build());
 
   public static CheckDescription SECONDARY_NAMENODE_MUST_BE_DELETED = new CheckDescription("SECONDARY_NAMENODE_MUST_BE_DELETED",
     PrereqCheckType.HOST,
@@ -272,20 +270,17 @@ public class CheckDescription {
           "After upgrading, Atlas can be reinstalled").build());
 
   public static CheckDescription SERVICE_PRESENCE_CHECK = new CheckDescription("SERVICE_PRESENCE_CHECK",
-      PrereqCheckType.SERVICE,
-      "Service Is Not Supported For Upgrades",
-      new ImmutableMap.Builder<String, String>()
-        .put(AbstractCheckDescriptor.DEFAULT,
-            "The %s service is currently installed on the cluster. " +
-            "This service does not support upgrades and must be removed before the upgrade can continue. " +
-            "After upgrading, %s can be reinstalled")
-        .put(ServicePresenceCheck.KEY_SERVICE_REMOVED,
-             "The %s service is currently installed on the cluster. " +
-             "This service is removed from the new release and must be removed before the upgrade can continue.")
-        .put(ServicePresenceCheck.KEY_SERVICE_REPLACED,
-            "The %s service is currently installed on the cluster. " +
-            "This service is removed from the new release and must be removed before the upgrade can continue. " +
-            "After upgrading, %s can be installed as the replacement.").build());
+    PrereqCheckType.SERVICE,
+    "Service Is Not Supported For Upgrades",
+    new ImmutableMap.Builder<String, String>()
+      .put(AbstractCheckDescriptor.DEFAULT,
+          "The %s service is currently installed on the cluster. " +
+          "This service does not support upgrades and must be removed before the upgrade can continue. " +
+          "After upgrading, %s can be reinstalled")
+      .put(ServicePresenceCheck.KEY_SERVICE_REMOVED,
+          "The %s service is currently installed on the cluster. " +
+          "This service is removed from the new release and must be removed before the upgrade can continue. " +
+          "After upgrading, %s can be installed").build());
 
   public static CheckDescription RANGER_SERVICE_AUDIT_DB_CHECK = new CheckDescription("RANGER_SERVICE_AUDIT_DB_CHECK",
     PrereqCheckType.SERVICE,
@@ -328,9 +323,23 @@ public class CheckDescription {
     PrereqCheckType.SERVICE,
     "Change Ranger SSL configuration path for Keystore and Truststore.",
     new ImmutableMap.Builder<String, String>()
-            .put(AbstractCheckDescriptor.DEFAULT,
-              "As Ranger is SSL enabled, Ranger SSL configurations will need to be changed from default value of /etc/ranger/*/conf folder to /etc/ranger/security. " +
-              "Since the certificates/keystores/truststores in this path may affect the upgrade/downgrade process, it is recommended to manually move the certificates/keystores/truststores out of the conf folders and change the appropriate config values before proceeding.").build());
+      .put(AbstractCheckDescriptor.DEFAULT,
+        "As Ranger is SSL enabled, Ranger SSL configurations will need to be changed from default value of /etc/ranger/*/conf folder to /etc/ranger/security. " +
+        "Since the certificates/keystores/truststores in this path may affect the upgrade/downgrade process, it is recommended to manually move the certificates/keystores/truststores out of the conf folders and change the appropriate config values before proceeding.").build());
+
+  public static CheckDescription JAVA_VERSION = new CheckDescription("JAVA_VERSION",
+      PrereqCheckType.CLUSTER,
+      "Verify Java version requirement",
+      new ImmutableMap.Builder<String, String>()
+        .put(AbstractCheckDescriptor.DEFAULT, "Ambari requires JDK with minimum version %s. Reconfigure Ambari with a JDK that meets the version requirement.")
+          .build());
+
+  public static CheckDescription COMPONENTS_EXIST_IN_TARGET_REPO = new CheckDescription("COMPONENTS_EXIST_IN_TARGET_REPO",
+      PrereqCheckType.CLUSTER,
+      "Verify Cluster Components Exist In Target Repository",
+      new ImmutableMap.Builder<String, String>()
+        .put(AbstractCheckDescriptor.DEFAULT, "The following components do not exist in the target repository's stack. They must be removed from the cluster before upgrading.")
+          .build());
 
   private String m_name;
   private PrereqCheckType m_type;
@@ -371,4 +380,4 @@ public class CheckDescription {
   public String getFail(String key) {
     return m_fails.containsKey(key) ? m_fails.get(key) : "";
   }
-}
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/ClientRetryPropertyCheck.java

@@ -18,9 +18,9 @@
 package org.apache.ambari.server.checks;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -31,6 +31,7 @@ import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 import org.apache.commons.lang.StringUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -58,10 +59,11 @@ public class ClientRetryPropertyCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("HDFS", "HIVE", "OOZIE"), false);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HDFS", "HIVE", "OOZIE");
   }
 
+
   /**
    * {@inheritDoc}
    */

ambari-server/src/main/java/org/apache/ambari/server/checks/ComponentsExistInRepoCheck.java

@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.ambari.server.checks;
+
+import java.text.MessageFormat;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.apache.ambari.server.AmbariException;
+import org.apache.ambari.server.StackAccessException;
+import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
+import org.apache.ambari.server.state.Cluster;
+import org.apache.ambari.server.state.ComponentInfo;
+import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.ServiceComponent;
+import org.apache.ambari.server.state.ServiceInfo;
+import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.stack.PrereqCheckStatus;
+import org.apache.ambari.server.state.stack.PrerequisiteCheck;
+import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
+import org.apache.commons.lang.StringUtils;
+
+import com.google.inject.Singleton;
+
+/**
+ * The {@link ComponentsExistInRepoCheck} is used to determine if any of the
+ * components scheduled for upgrade do not exist in the target repository or
+ * stack.
+ */
+@Singleton
+@UpgradeCheck(
+    group = UpgradeCheckGroup.TOPOLOGY,
+    required = { UpgradeType.ROLLING, UpgradeType.NON_ROLLING, UpgradeType.HOST_ORDERED })
+public class ComponentsExistInRepoCheck extends AbstractCheckDescriptor {
+
+  /**
+   * Constructor.
+   */
+  public ComponentsExistInRepoCheck() {
+    super(CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO);
+  }
+
+  @Override
+  public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+      throws AmbariException {
+    final String clusterName = request.getClusterName();
+    final Cluster cluster = clustersProvider.get().getCluster(clusterName);
+    RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+
+    StackId sourceStack = request.getSourceStackId();
+    StackId targetStack = repositoryVersion.getStackId();
+
+    Set<String> failedServices = new TreeSet<>();
+    Set<String> failedComponents = new TreeSet<>();
+
+    Set<String> servicesInUpgrade = getServicesInUpgrade(request);
+    for (String serviceName : servicesInUpgrade) {
+      try {
+        ServiceInfo serviceInfo = ambariMetaInfo.get().getService(targetStack.getStackName(),
+            targetStack.getStackVersion(), serviceName);
+
+        if (serviceInfo.isDeleted() || !serviceInfo.isValid()) {
+          failedServices.add(serviceName);
+          continue;
+        }
+
+        Service service = cluster.getService(serviceName);
+        Map<String, ServiceComponent> componentsInUpgrade = service.getServiceComponents();
+        for (String componentName : componentsInUpgrade.keySet()) {
+          try {
+            ComponentInfo componentInfo = ambariMetaInfo.get().getComponent(
+                targetStack.getStackName(), targetStack.getStackVersion(), serviceName,
+                componentName);
+
+            // if this component isn't included in the upgrade, then skip it
+            if (!componentInfo.isVersionAdvertised()) {
+              continue;
+            }
+
+            if (componentInfo.isDeleted()) {
+              failedComponents.add(componentName);
+            }
+
+          } catch (StackAccessException stackAccessException) {
+            failedComponents.add(componentName);
+          }
+        }
+      } catch (StackAccessException stackAccessException) {
+        failedServices.add(serviceName);
+      }
+    }
+
+    if( failedServices.isEmpty() && failedComponents.isEmpty() ){
+      prerequisiteCheck.setStatus(PrereqCheckStatus.PASS);
+      return;
+    }
+
+    LinkedHashSet<String> failedOn = new LinkedHashSet<>();
+    failedOn.addAll(failedServices);
+    failedOn.addAll(failedComponents);
+
+    prerequisiteCheck.setFailedOn(failedOn);
+    prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
+
+    String message = "The following {0} exist in {1} but are not included in {2}. They must be removed before upgrading.";
+    String messageFragment = "";
+    if (!failedServices.isEmpty()) {
+      messageFragment = "services";
+    }
+
+    if( !failedComponents.isEmpty() ){
+      if(!StringUtils.isEmpty(messageFragment)){
+        messageFragment += " and ";
+      }
+
+      messageFragment += "components";
+    }
+
+    message = MessageFormat.format(message, messageFragment, sourceStack, targetStack);
+    prerequisiteCheck.setFailReason(message);
+  }
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/ComponentsInstallationCheck.java

@@ -66,8 +66,9 @@ public class ComponentsInstallationCheck extends AbstractCheckDescriptor {
     // Preq-req check should fail if any service component is in INSTALL_FAILED state
     Set<String> installFailedHostComponents = new HashSet<>();
 
-    for (Map.Entry<String, Service> serviceEntry : cluster.getServices().entrySet()) {
-      final Service service = serviceEntry.getValue();
+    Set<String> servicesInUpgrade = getServicesInUpgrade(request);
+    for (String serviceName : servicesInUpgrade) {
+      final Service service = cluster.getService(serviceName);
       // Skip service if it is in maintenance mode
       if (service.getMaintenanceState() != MaintenanceState.ON) {
         Map<String, ServiceComponent> serviceComponents = service.getServiceComponents();

ambari-server/src/main/java/org/apache/ambari/server/checks/ConfigurationMergeCheck.java

@@ -63,8 +63,7 @@ public class ConfigurationMergeCheck extends AbstractCheckDescriptor {
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
       throws AmbariException {
 
-    String stackName = request.getTargetStackId().getStackName();
-    RepositoryVersionEntity rve = repositoryVersionDaoProvider.get().findByStackNameAndVersion(stackName, request.getTargetVersion());
+    RepositoryVersionEntity rve = request.getTargetRepositoryVersion();
 
     Map<String, Map<String, ThreeWayValue>> changes =
         m_mergeHelper.getConflicts(request.getClusterName(), rve.getStackId());

ambari-server/src/main/java/org/apache/ambari/server/checks/HealthCheck.java

@@ -99,7 +99,8 @@ public class HealthCheck extends AbstractCheckDescriptor {
       prerequisiteCheck.getFailedOn().add(clusterName);
       prerequisiteCheck.setStatus(PrereqCheckStatus.WARNING);
       String failReason = getFailReason(prerequisiteCheck, request);
-      prerequisiteCheck.setFailReason(String.format(failReason, StringUtils.join(errorMessages, "\n")));
+      prerequisiteCheck.setFailReason(
+          String.format(failReason, StringUtils.join(errorMessages, System.lineSeparator())));
     }
   }
 

ambari-server/src/main/java/org/apache/ambari/server/checks/HiveDynamicServiceDiscoveryCheck.java

@@ -18,12 +18,14 @@
 package org.apache.ambari.server.checks;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
+import org.apache.ambari.server.state.StackId;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
@@ -31,6 +33,7 @@ import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 import org.apache.ambari.server.utils.VersionUtils;
 import org.apache.commons.lang.StringUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -60,8 +63,8 @@ public class HiveDynamicServiceDiscoveryCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("HIVE"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HIVE");
   }
 
   /**
@@ -109,9 +112,11 @@ public class HiveDynamicServiceDiscoveryCheck extends AbstractCheckDescriptor {
           String minStackName = minStack[0];
           String minStackVersion = minStack[1];
           if (minStackName.equals(request.getSourceStackId().getStackName())) {
+            RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+            StackId targetStackId = repositoryVersion.getStackId();
             if (VersionUtils.compareVersions(request.getSourceStackId().getStackVersion(), minStackVersion) < 0
-                && VersionUtils.compareVersions(request.getTargetStackId().getStackVersion(), minStackVersion) < 0
-                && VersionUtils.compareVersions(request.getSourceStackId().getStackVersion(), request.getTargetStackId().getStackVersion()) < 0) {
+                && VersionUtils.compareVersions(targetStackId.getStackVersion(), minStackVersion) < 0
+                && VersionUtils.compareVersions(request.getSourceStackId().getStackVersion(), targetStackId.getStackVersion()) < 0) {
               checkStatus = PrereqCheckStatus.WARNING;
             }
           }

ambari-server/src/main/java/org/apache/ambari/server/checks/HiveMultipleMetastoreCheck.java

@@ -17,8 +17,8 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.ServiceComponentNotFoundException;
@@ -30,6 +30,7 @@ import org.apache.ambari.server.state.ServiceComponentHost;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -51,8 +52,8 @@ public class HiveMultipleMetastoreCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("HIVE"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HIVE");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/HiveNotRollingWarning.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -25,6 +25,7 @@ import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -52,14 +53,10 @@ public class HiveNotRollingWarning extends AbstractCheckDescriptor {
 
   /**
    * {@inheritDoc}
-   * <p/>
-   * This check is only applicable if Hive is installed and the upgrade type is
-   * {@link UpgradeType#ROLLING}.
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    boolean isApplicable = super.isApplicable(request, Arrays.asList("HIVE"), true);
-    return isApplicable && request.getUpgradeType() == UpgradeType.ROLLING;
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HIVE");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/HostsMasterMaintenanceCheck.java

@@ -23,6 +23,7 @@ import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Host;
 import org.apache.ambari.server.state.MaintenanceState;
@@ -57,11 +58,6 @@ public class HostsMasterMaintenanceCheck extends AbstractCheckDescriptor {
     super(CheckDescription.HOSTS_MASTER_MAINTENANCE);
   }
 
-  @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-      return super.isApplicable(request) && request.getTargetVersion() != null;
-  }
-
   @Override
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) throws AmbariException {
     final String clusterName = request.getClusterName();
@@ -70,13 +66,18 @@ public class HostsMasterMaintenanceCheck extends AbstractCheckDescriptor {
     final Set<String> hostsWithMasterComponent = new HashSet<>();
 
     // TODO AMBARI-12698, need to pass the upgrade pack to use in the request, or at least the type.
-    final String upgradePackName = repositoryVersionHelper.get().getUpgradePackageName(stackId.getStackName(), stackId.getStackVersion(), request.getTargetVersion(), null);
+    RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+
+    final String upgradePackName = repositoryVersionHelper.get().getUpgradePackageName(
+        stackId.getStackName(), stackId.getStackVersion(), repositoryVersion.getVersion(), null);
+
     if (upgradePackName == null) {
       prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
       String fail = getFailReason(KEY_NO_UPGRADE_NAME, prerequisiteCheck, request);
       prerequisiteCheck.setFailReason(String.format(fail, stackId.getStackName(), stackId.getStackVersion()));
       return;
     }
+
     final UpgradePack upgradePack = ambariMetaInfo.get().getUpgradePacks(stackId.getStackName(), stackId.getStackVersion()).get(upgradePackName);
     if (upgradePack == null) {
       prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
@@ -84,10 +85,12 @@ public class HostsMasterMaintenanceCheck extends AbstractCheckDescriptor {
       prerequisiteCheck.setFailReason(String.format(fail, upgradePackName));
       return;
     }
+
     final Set<String> componentsFromUpgradePack = new HashSet<>();
     for (Map<String, ProcessingComponent> task: upgradePack.getTasks().values()) {
       componentsFromUpgradePack.addAll(task.keySet());
     }
+
     for (Service service: cluster.getServices().values()) {
       for (ServiceComponent serviceComponent: service.getServiceComponents().values()) {
         if (serviceComponent.isMasterComponent() && componentsFromUpgradePack.contains(serviceComponent.getName())) {
@@ -95,6 +98,7 @@ public class HostsMasterMaintenanceCheck extends AbstractCheckDescriptor {
         }
       }
     }
+
     final Map<String, Host> clusterHosts = clustersProvider.get().getHostsForCluster(clusterName);
     for (Map.Entry<String, Host> hostEntry : clusterHosts.entrySet()) {
       final Host host = hostEntry.getValue();
@@ -102,6 +106,7 @@ public class HostsMasterMaintenanceCheck extends AbstractCheckDescriptor {
         prerequisiteCheck.getFailedOn().add(host.getHostName());
       }
     }
+
     if (!prerequisiteCheck.getFailedOn().isEmpty()) {
       prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
       prerequisiteCheck.setFailReason(getFailReason(prerequisiteCheck, request));

ambari-server/src/main/java/org/apache/ambari/server/checks/HostsRepositoryVersionCheck.java

@@ -25,7 +25,6 @@ import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.orm.entities.HostVersionEntity;
 import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
-import org.apache.ambari.server.orm.entities.StackEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Host;
 import org.apache.ambari.server.state.MaintenanceState;
@@ -49,8 +48,6 @@ import com.google.inject.Singleton;
     required = { UpgradeType.ROLLING, UpgradeType.NON_ROLLING, UpgradeType.HOST_ORDERED })
 public class HostsRepositoryVersionCheck extends AbstractCheckDescriptor {
 
-  static final String KEY_NO_REPO_VERSION = "no_repo_version";
-
   /**
    * Constructor.
    */
@@ -58,18 +55,12 @@ public class HostsRepositoryVersionCheck extends AbstractCheckDescriptor {
     super(CheckDescription.HOSTS_REPOSITORY_VERSION);
   }
 
-  @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request) && request.getTargetVersion() != null;
-  }
-
   @Override
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
       throws AmbariException {
     final String clusterName = request.getClusterName();
     final Cluster cluster = clustersProvider.get().getCluster(clusterName);
     final Map<String, Host> clusterHosts = clustersProvider.get().getHostsForCluster(clusterName);
-    final StackId stackId = request.getSourceStackId();
 
     for (Host host : clusterHosts.values()) {
       // hosts in MM will produce a warning if they do not have the repo version
@@ -78,48 +69,19 @@ public class HostsRepositoryVersionCheck extends AbstractCheckDescriptor {
         continue;
       }
 
-      if (null != request.getTargetVersion()) {
-        boolean found = false;
-
-        Set<RepositoryVersionState> allowed = EnumSet.of(RepositoryVersionState.INSTALLED,
-            RepositoryVersionState.NOT_REQUIRED);
-        if (request.isRevert()) {
-          allowed.add(RepositoryVersionState.CURRENT);
-        }
-
-        for (HostVersionEntity hve : hostVersionDaoProvider.get().findByHost(host.getHostName())) {
-
-          if (hve.getRepositoryVersion().getVersion().equals(request.getTargetVersion())
-              && allowed.contains(hve.getState())) {
-            found = true;
-            break;
-          }
-        }
-
-        if (!found) {
-          prerequisiteCheck.getFailedOn().add(host.getHostName());
-        }
-      } else {
-        final RepositoryVersionEntity repositoryVersion = repositoryVersionDaoProvider.get().findByStackAndVersion(
-            stackId, request.getTargetVersion());
-        if (repositoryVersion == null) {
-          prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
-          prerequisiteCheck.setFailReason(
-              getFailReason(KEY_NO_REPO_VERSION, prerequisiteCheck, request));
-          prerequisiteCheck.getFailedOn().addAll(clusterHosts.keySet());
-          return;
-        }
+      RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
+      StackId repositoryStackId = repositoryVersion.getStackId();
 
-        StackEntity repositoryStackEntity = repositoryVersion.getStack();
-        StackId repositoryStackId = new StackId(repositoryStackEntity.getStackName(),
-            repositoryStackEntity.getStackVersion());
+      // get the host version entity for this host and repository
+      final HostVersionEntity hostVersion = hostVersionDaoProvider.get().findByClusterStackVersionAndHost(
+          clusterName, repositoryStackId, repositoryVersion.getVersion(), host.getHostName());
 
-        final HostVersionEntity hostVersion = hostVersionDaoProvider.get().findByClusterStackVersionAndHost(
-            clusterName, repositoryStackId, repositoryVersion.getVersion(), host.getHostName());
+      // the repo needs to either be installed or not required
+      Set<RepositoryVersionState> okStates = EnumSet.of(RepositoryVersionState.INSTALLED,
+          RepositoryVersionState.NOT_REQUIRED);
 
-        if (hostVersion == null || hostVersion.getState() != RepositoryVersionState.INSTALLED) {
-          prerequisiteCheck.getFailedOn().add(host.getHostName());
-        }
+      if (hostVersion == null || !okStates.contains(hostVersion.getState())) {
+        prerequisiteCheck.getFailedOn().add(host.getHostName());
       }
     }
 
@@ -128,4 +90,4 @@ public class HostsRepositoryVersionCheck extends AbstractCheckDescriptor {
       prerequisiteCheck.setFailReason(getFailReason(prerequisiteCheck, request));
     }
   }
-}
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/InstallPackagesCheck.java

@@ -59,16 +59,15 @@ public class InstallPackagesCheck extends AbstractCheckDescriptor {
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) throws AmbariException {
     final String clusterName = request.getClusterName();
     final Cluster cluster = clustersProvider.get().getCluster(clusterName);
-    final StackId targetStackId = request.getTargetStackId();
-    final String stackName = targetStackId.getStackName();
-    final String repoVersion = request.getTargetVersion();
+    RepositoryVersionEntity repositoryVersion = request.getTargetRepositoryVersion();
 
-    final RepositoryVersionEntity rve = repositoryVersionDaoProvider.get().findByStackNameAndVersion(stackName, request.getTargetVersion());
-    if (StringUtils.isBlank(rve.getVersion()) || !rve.getVersion().matches("^\\d+(\\.\\d+)*\\-\\d+$")) {
+    final StackId targetStackId = repositoryVersion.getStackId();
+
+    if (!repositoryVersion.getVersion().matches("^\\d+(\\.\\d+)*\\-\\d+$")) {
       String message = MessageFormat.format("The Repository Version {0} for Stack {1} must contain a \"-\" followed by a build number. " +
               "Make sure that another registered repository does not have the same repo URL or " +
-              "shares the same build number. Next, try reinstalling the Repository Version.", rve.getVersion(), rve.getStackVersion());
-      prerequisiteCheck.getFailedOn().add("Repository Version " + rve.getVersion());
+              "shares the same build number. Next, try reinstalling the Repository Version.", repositoryVersion.getVersion(), repositoryVersion.getStackVersion());
+      prerequisiteCheck.getFailedOn().add("Repository Version " + repositoryVersion.getVersion());
       prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
       prerequisiteCheck.setFailReason(message);
       return;
@@ -79,7 +78,7 @@ public class InstallPackagesCheck extends AbstractCheckDescriptor {
     for (Host host : cluster.getHosts()) {
       if (host.getMaintenanceState(cluster.getClusterId()) != MaintenanceState.ON) {
         for (HostVersionEntity hve : hostVersionDaoProvider.get().findByHost(host.getHostName())) {
-          if (hve.getRepositoryVersion().getVersion().equals(request.getTargetVersion())
+          if (StringUtils.equals(hve.getRepositoryVersion().getVersion(), repositoryVersion.getVersion())
               && hve.getState() == RepositoryVersionState.INSTALL_FAILED) {
             failedHosts.add(host.getHostName());
           }
@@ -91,7 +90,8 @@ public class InstallPackagesCheck extends AbstractCheckDescriptor {
       String message = MessageFormat.format("Hosts in cluster [{0},{1},{2},{3}] are in INSTALL_FAILED state because " +
               "Install Packages had failed. Please re-run Install Packages, if necessary place following hosts " +
               "in Maintenance mode: {4}", cluster.getClusterName(), targetStackId.getStackName(),
-          targetStackId.getStackVersion(), repoVersion, StringUtils.join(failedHosts, ", "));
+          targetStackId.getStackVersion(), repositoryVersion.getVersion(),
+          StringUtils.join(failedHosts, ", "));
       prerequisiteCheck.setFailedOn(new LinkedHashSet<>(failedHosts));
       prerequisiteCheck.setStatus(PrereqCheckStatus.FAIL);
       prerequisiteCheck.setFailReason(message);

ambari-server/src/main/java/org/apache/ambari/server/checks/KafkaKerberosCheck.java

@@ -18,7 +18,7 @@
 
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -27,6 +27,7 @@ import org.apache.ambari.server.state.SecurityType;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -47,9 +48,12 @@ public class KafkaKerberosCheck extends AbstractCheckDescriptor {
     super(CheckDescription.KAFKA_KERBEROS_CHECK);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList(KAFKA_SERVICE), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet(KAFKA_SERVICE);
   }
 
   @Override

ambari-server/src/main/java/org/apache/ambari/server/checks/MapReduce2JobHistoryStatePreservingCheck.java

@@ -18,8 +18,8 @@
 package org.apache.ambari.server.checks;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -27,6 +27,7 @@ import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.commons.lang.StringUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -57,8 +58,8 @@ public class MapReduce2JobHistoryStatePreservingCheck extends AbstractCheckDescr
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("MAPREDUCE2"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("MAPREDUCE2");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/RangerAuditDbCheck.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -26,6 +26,7 @@ import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -42,9 +43,12 @@ public class RangerAuditDbCheck extends AbstractCheckDescriptor{
     super(CheckDescription.RANGER_SERVICE_AUDIT_DB_CHECK);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList(serviceName), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet(serviceName);
   }
 
   @Override

ambari-server/src/main/java/org/apache/ambari/server/checks/RangerPasswordCheck.java

@@ -27,22 +27,21 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.configuration.ComponentSSLConfiguration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.controller.internal.URLStreamProvider;
-import org.apache.ambari.server.state.Service;
-import org.apache.ambari.server.state.StackId;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
-import org.apache.ambari.server.utils.VersionUtils;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.Sets;
 import com.google.gson.Gson;
 import com.google.inject.Singleton;
 
@@ -74,25 +73,11 @@ public class RangerPasswordCheck extends AbstractCheckDescriptor {
   }
 
   /**
-   * Verifies that the check can be run.  If the stack is HDP and 2.3 or higher, allow
-   * this to run.  If the stack is not HDP, the check should run.
+   * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    if (!super.isApplicable(request, Arrays.asList("RANGER"), true)) {
-      return false;
-    }
-
-    Service service = getCluster(request).getService("RANGER");
-
-    StackId stackId = service.getDesiredStackId();
-    if (stackId.getStackName().equals("HDP")) {
-      String sourceVersion = request.getSourceStackId().getStackVersion();
-
-      return VersionUtils.compareVersions(sourceVersion, "2.3.0.0") >= 0;
-    }
-
-    return true;
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("RANGER");
   }
 
   @Override
@@ -293,7 +278,7 @@ public class RangerPasswordCheck extends AbstractCheckDescriptor {
    */
   private boolean checkRangerUser(URLStreamProvider streamProvider, String rangerUserUrl,
       String username, String password, String userToSearch, PrerequisiteCheck check,
-      PrereqCheckRequest request, List<String> warnReasons) {
+      PrereqCheckRequest request, List<String> warnReasons) throws AmbariException {
 
     String url = String.format("%s?name=%s", rangerUserUrl, userToSearch);
 
@@ -390,4 +375,4 @@ public class RangerPasswordCheck extends AbstractCheckDescriptor {
   }
 
 
-}
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/RangerSSLConfigCheck.java

@@ -18,7 +18,7 @@
 package org.apache.ambari.server.checks;
 
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -27,6 +27,7 @@ import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 
@@ -54,8 +55,8 @@ public class RangerSSLConfigCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList(serviceName), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet(serviceName);
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/SecondaryNamenodeDeletedCheck.java

@@ -33,6 +33,7 @@ import org.apache.ambari.server.state.ServiceComponent;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 
@@ -53,18 +54,21 @@ public class SecondaryNamenodeDeletedCheck extends AbstractCheckDescriptor {
     super(CheckDescription.SECONDARY_NAMENODE_MUST_BE_DELETED);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    if (!super.isApplicable(request, Arrays.asList(HDFS_SERVICE_NAME), true)) {
-      return false;
-    }
-
-    PrereqCheckStatus ha = request.getResult(CheckDescription.SERVICES_NAMENODE_HA);
-    if (null != ha && ha == PrereqCheckStatus.FAIL) {
-      return false;
-    }
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet(HDFS_SERVICE_NAME);
+  }
 
-    return true;
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public List<CheckQualification> getQualifications() {
+    return Arrays.<CheckQualification> asList(
+        new PriorCheckQualification(CheckDescription.SERVICES_NAMENODE_HA));
   }
 
   // TODO AMBARI-12698, there are 2 ways to filter the prechecks.

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicePresenceCheck.java

@@ -109,7 +109,7 @@ public class ServicePresenceCheck extends AbstractCheckDescriptor{
     for(String service: removedServices){
       if (installedServices.contains(service.toUpperCase())){
         prerequisiteCheck.getFailedOn().add(service);
-        String msg = String.format(reason, service);
+        String msg = String.format(reason, service, service);
         failReasons.add(msg);
       }
     }
@@ -159,7 +159,7 @@ public class ServicePresenceCheck extends AbstractCheckDescriptor{
   +   * @return service names
   +   * */
   private List<String> getRemovedServices(PrereqCheckRequest request){
-    List<String> result = new ArrayList<String>();
+    List<String> result = new ArrayList<>();
     String value = getPropertyValue(request, REMOVED_SERVICES_PROPERTY_NAME);
     if (null != value){
       String[] services = value.split(",");

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesMaintenanceModeCheck.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -49,10 +49,11 @@ public class ServicesMaintenanceModeCheck extends AbstractCheckDescriptor {
 
   @Override
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) throws AmbariException {
-    final String clusterName = request.getClusterName();
-    final Cluster cluster = clustersProvider.get().getCluster(clusterName);
-    for (Map.Entry<String, Service> serviceEntry : cluster.getServices().entrySet()) {
-      final Service service = serviceEntry.getValue();
+    final Cluster cluster = clustersProvider.get().getCluster(request.getClusterName());
+    Set<String> servicesInUpgrade = getServicesInUpgrade(request);
+
+    for (String serviceName : servicesInUpgrade) {
+      final Service service = cluster.getService(serviceName);
       if (!service.isClientOnlyService() && service.getMaintenanceState() == MaintenanceState.ON) {
         prerequisiteCheck.getFailedOn().add(service.getName());
       }

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesMapReduceDistributedCacheCheck.java

@@ -21,6 +21,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -32,6 +33,7 @@ import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
 import org.apache.commons.lang.StringUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -47,20 +49,21 @@ public class ServicesMapReduceDistributedCacheCheck extends AbstractCheckDescrip
   static final String DFS_PROTOCOLS_REGEX_PROPERTY_NAME = "dfs-protocols-regex";
   static final String DFS_PROTOCOLS_REGEX_DEFAULT = "^([^:]*dfs|wasb|ecs):.*";
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request)
-    throws AmbariException {
-
-    if (!super.isApplicable(request, Arrays.asList("YARN"), true)) {
-      return false;
-    }
-
-    PrereqCheckStatus ha = request.getResult(CheckDescription.SERVICES_NAMENODE_HA);
-    if (null != ha && ha == PrereqCheckStatus.FAIL) {
-      return false;
-    }
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("YARN");
+  }
 
-    return true;
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public List<CheckQualification> getQualifications() {
+    return Arrays.<CheckQualification> asList(
+        new PriorCheckQualification(CheckDescription.SERVICES_NAMENODE_HA));
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesNamenodeHighAvailabilityCheck.java

@@ -17,8 +17,8 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -28,6 +28,7 @@ import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -44,11 +45,15 @@ public class ServicesNamenodeHighAvailabilityCheck extends AbstractCheckDescript
     super(CheckDescription.SERVICES_NAMENODE_HA);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("HDFS"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HDFS");
   }
 
+
   @Override
   public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request) throws AmbariException {
     final String clusterName = request.getClusterName();

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesNamenodeTruncateCheck.java

@@ -18,6 +18,8 @@
 package org.apache.ambari.server.checks;
 
 import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -26,6 +28,7 @@ import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -42,18 +45,21 @@ public class ServicesNamenodeTruncateCheck extends AbstractCheckDescriptor {
     super(CheckDescription.SERVICES_NAMENODE_TRUNCATE);
   }
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    if (!super.isApplicable(request, Arrays.asList("HDFS"), true)) {
-      return false;
-    }
-
-    PrereqCheckStatus ha = request.getResult(CheckDescription.SERVICES_NAMENODE_HA);
-    if (null != ha && ha == PrereqCheckStatus.FAIL) {
-      return false;
-    }
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("HDFS");
+  }
 
-    return true;
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public List<CheckQualification> getQualifications() {
+    return Arrays.<CheckQualification> asList(
+        new PriorCheckQualification(CheckDescription.SERVICES_NAMENODE_HA));
   }
 
   @Override

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesTezDistributedCacheCheck.java

@@ -21,6 +21,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -32,6 +33,7 @@ import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
 import org.apache.commons.lang.StringUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -49,18 +51,21 @@ public class ServicesTezDistributedCacheCheck extends AbstractCheckDescriptor {
   static final String DFS_PROTOCOLS_REGEX_PROPERTY_NAME = "dfs-protocols-regex";
   static final String DFS_PROTOCOLS_REGEX_DEFAULT = "^([^:]*dfs|wasb|ecs):.*";
 
+  /**
+   * {@inheritDoc}
+   */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    if (!super.isApplicable(request, Arrays.asList("TEZ"), true)) {
-      return false;
-    }
-
-    PrereqCheckStatus ha = request.getResult(CheckDescription.SERVICES_NAMENODE_HA);
-    if (null != ha && ha == PrereqCheckStatus.FAIL) {
-      return false;
-    }
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("TEZ");
+  }
 
-    return true;
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public List<CheckQualification> getQualifications() {
+    return Arrays.<CheckQualification> asList(
+        new PriorCheckQualification(CheckDescription.SERVICES_NAMENODE_HA));
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesUpCheck.java

@@ -91,9 +91,9 @@ public class ServicesUpCheck extends AbstractCheckDescriptor {
     List<String> errorMessages = new ArrayList<>();
     Set<String> failedServiceNames = new HashSet<>();
 
-    for (Map.Entry<String, Service> serviceEntry : cluster.getServices().entrySet()) {
-      final Service service = serviceEntry.getValue();
-      StackId stackId = service.getDesiredStackId();
+    Set<String> servicesInUpgrade = getServicesInUpgrade(request);
+    for (String serviceName : servicesInUpgrade) {
+      final Service service = cluster.getService(serviceName);
 
       // Ignore services like Tez that are clientOnly.
       if (service.isClientOnlyService()) {
@@ -131,6 +131,7 @@ public class ServicesUpCheck extends AbstractCheckDescriptor {
         // non-master, "true" slaves with cardinality 1+
         boolean checkThreshold = false;
         if (!serviceComponent.isMasterComponent()) {
+          StackId stackId = service.getDesiredStackId();
           ComponentInfo componentInfo = ambariMetaInfo.get().getComponent(stackId.getStackName(),
               stackId.getStackVersion(), serviceComponent.getServiceName(),
               serviceComponent.getName());
@@ -194,6 +195,8 @@ public class ServicesUpCheck extends AbstractCheckDescriptor {
    * purposes of this check. Component type, maintenance mode, and state are
    * taken into account.
    *
+   * @param clusters
+   *          the clusters instance
    * @param cluster
    *          the cluster
    * @param serviceComponent
@@ -225,4 +228,4 @@ public class ServicesUpCheck extends AbstractCheckDescriptor {
         return false;
     }
   }
-}
+}

ambari-server/src/main/java/org/apache/ambari/server/checks/ServicesYarnWorkPreservingCheck.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -25,6 +25,7 @@ import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.commons.lang.BooleanUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -45,8 +46,8 @@ public class ServicesYarnWorkPreservingCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("YARN"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("YARN");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/StormShutdownWarning.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -25,6 +25,7 @@ import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -50,14 +51,10 @@ public class StormShutdownWarning extends AbstractCheckDescriptor {
 
   /**
    * {@inheritDoc}
-   * <p/>
-   * This check is only applicable if Storm is installed and the upgrade type is
-   * {@link UpgradeType#ROLLING}.
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    boolean isApplicable = super.isApplicable(request, Arrays.asList("STORM"), true);
-    return isApplicable && request.getUpgradeType() == UpgradeType.ROLLING;
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("STORM");
   }
 
   /**

ambari-server/src/main/java/org/apache/ambari/server/checks/YarnRMHighAvailabilityCheck.java

@@ -17,7 +17,7 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -25,6 +25,7 @@ import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.commons.lang.BooleanUtils;
 
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -46,10 +47,9 @@ public class YarnRMHighAvailabilityCheck extends AbstractCheckDescriptor {
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    return super.isApplicable(request, Arrays.asList("YARN"), true);
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("YARN");
   }
-
   /**
    * {@inheritDoc}
    */

ambari-server/src/main/java/org/apache/ambari/server/checks/YarnTimelineServerStatePreservingCheck.java

@@ -17,8 +17,9 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
@@ -30,6 +31,8 @@ import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
 import org.apache.ambari.server.utils.VersionUtils;
 import org.apache.commons.lang.BooleanUtils;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import com.google.inject.Singleton;
 
 /**
@@ -55,43 +58,16 @@ public class YarnTimelineServerStatePreservingCheck extends AbstractCheckDescrip
    * {@inheritDoc}
    */
   @Override
-  public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
-    if (!super.isApplicable(request, Arrays.asList("YARN"), true)) {
-      return false;
-    }
-
-    final Cluster cluster = clustersProvider.get().getCluster(request.getClusterName());
-
-    String minApplicableStackVersion = null;
-    PrerequisiteCheckConfig prerequisiteCheckConfig = request.getPrerequisiteCheckConfig();
-    Map<String, String> checkProperties = null;
-    if(prerequisiteCheckConfig != null) {
-      checkProperties = prerequisiteCheckConfig.getCheckProperties(this.getClass().getName());
-    }
-    if(checkProperties != null && checkProperties.containsKey(MIN_APPLICABLE_STACK_VERSION_PROPERTY_NAME)) {
-      minApplicableStackVersion = checkProperties.get(MIN_APPLICABLE_STACK_VERSION_PROPERTY_NAME);
-    }
-
-    // Due to the introduction of YARN Timeline state recovery only from certain
-    // stack-versions onwards, this check is not applicable to earlier versions
-    // of the stack.
-    // Applicable only if min-applicable-stack-version config property is not defined, or
-    // version equals or exceeds the configured version.
-    if(minApplicableStackVersion != null && !minApplicableStackVersion.isEmpty()) {
-      String[] minStack = minApplicableStackVersion.split("-");
-      if(minStack.length == 2) {
-        String minStackName = minStack[0];
-        String minStackVersion = minStack[1];
-        Service yarnService = cluster.getService("YARN");
-        String stackName = yarnService.getDesiredStackId().getStackName();
-        if (minStackName.equals(stackName)) {
-          String currentRepositoryVersion = yarnService.getDesiredRepositoryVersion().getVersion();
-          return VersionUtils.compareVersions(currentRepositoryVersion, minStackVersion) >= 0;
-        }
-      }
-    }
+  public Set<String> getApplicableServices() {
+    return Sets.newHashSet("YARN");
+  }
 
-    return true;
+  /**
+   * {@inheritDoc}
+   */
+  @Override
+  public List<CheckQualification> getQualifications() {
+    return Lists.<CheckQualification> newArrayList(new YarnTimelineServerMinVersionQualification());
   }
 
   /**
@@ -108,4 +84,53 @@ public class YarnTimelineServerStatePreservingCheck extends AbstractCheckDescrip
       prerequisiteCheck.setFailReason(getFailReason(prerequisiteCheck, request));
     }
   }
+
+  /**
+   * The {@link YarnTimelineServerMinVersionQualification} is used to determine
+   * if the ATS component needs to have the
+   * {@value #MIN_APPLICABLE_STACK_VERSION_PROPERTY_NAME} set.
+   */
+  private class YarnTimelineServerMinVersionQualification implements CheckQualification {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isApplicable(PrereqCheckRequest request) throws AmbariException {
+      final Cluster cluster = clustersProvider.get().getCluster(request.getClusterName());
+
+      String minApplicableStackVersion = null;
+      PrerequisiteCheckConfig prerequisiteCheckConfig = request.getPrerequisiteCheckConfig();
+      Map<String, String> checkProperties = null;
+      if(prerequisiteCheckConfig != null) {
+        checkProperties = prerequisiteCheckConfig.getCheckProperties(this.getClass().getName());
+      }
+
+      if(checkProperties != null && checkProperties.containsKey(MIN_APPLICABLE_STACK_VERSION_PROPERTY_NAME)) {
+        minApplicableStackVersion = checkProperties.get(MIN_APPLICABLE_STACK_VERSION_PROPERTY_NAME);
+      }
+
+      // Due to the introduction of YARN Timeline state recovery only from certain
+      // stack-versions onwards, this check is not applicable to earlier versions
+      // of the stack.
+      // Applicable only if min-applicable-stack-version config property is not defined, or
+      // version equals or exceeds the configured version.
+      if(minApplicableStackVersion != null && !minApplicableStackVersion.isEmpty()) {
+        String[] minStack = minApplicableStackVersion.split("-");
+        if(minStack.length == 2) {
+          String minStackName = minStack[0];
+          String minStackVersion = minStack[1];
+          Service yarnService = cluster.getService("YARN");
+          String stackName = yarnService.getDesiredStackId().getStackName();
+          if (minStackName.equals(stackName)) {
+            String currentRepositoryVersion = yarnService.getDesiredRepositoryVersion().getVersion();
+            return VersionUtils.compareVersions(currentRepositoryVersion, minStackVersion) >= 0;
+          }
+        }
+      }
+
+      return true;
+
+    }
+  }
 }

ambari-server/src/main/java/org/apache/ambari/server/controller/PrereqCheckRequest.java

@@ -64,14 +64,6 @@ public class PrereqCheckRequest {
     return m_upgradeType;
   }
 
-  public String getTargetVersion() {
-    if (null == m_targetRepositoryVersion) {
-      return null;
-    }
-
-    return m_targetRepositoryVersion.getVersion();
-  }
-
   /**
    * Sets the result of a check.
    * @param description the description
@@ -109,19 +101,6 @@ public class PrereqCheckRequest {
     m_sourceStackId = sourceStackId;
   }
 
-  /**
-   * Gets the target stack of the upgrade.
-   *
-   * @return the targetStackId
-   */
-  public StackId getTargetStackId() {
-    if (null == m_targetRepositoryVersion) {
-      return null;
-    }
-
-    return m_targetRepositoryVersion.getStackId();
-  }
-
   /**
    * Gets the target repository of the upgrade.
    *

ambari-server/src/main/java/org/apache/ambari/server/state/CheckHelper.java

@@ -73,7 +73,9 @@ public class CheckHelper {
           applicablePreChecks.add(new DescriptorPreCheck(checkDescriptor, prerequisiteCheck));
         }
       } catch (Exception ex) {
-        LOG.error("Check " + checkDescriptor.getDescription().name() + " failed", ex);
+        LOG.error(
+            "Unable to determine whether the pre-upgrade check {} is applicable to this upgrade",
+            checkDescriptor.getDescription().name(), ex);
       }
     }
     return applicablePreChecks;

ambari-server/src/main/resources/stacks/HDP/2.0.6/hooks/before-START/scripts/params.py

@@ -337,12 +337,11 @@ if dfs_ha_enabled:
      namenode_rpc = nn_host
    pass
  pass
-elif 'dfs.namenode.rpc-address' in config['configurations']['hdfs-site']:
-  namenode_rpc = default('/configurations/hdfs-site/dfs.namenode.rpc-address', None)
 else:
-  namenode_rpc = default_fs
+  namenode_rpc = default('/configurations/hdfs-site/dfs.namenode.rpc-address', default_fs)
 
-if namenode_rpc:
+# if HDFS is not installed in the cluster, then don't try to access namenode_rpc
+if "core-site" in config['configurations'] and namenode_rpc:
   port_str = namenode_rpc.split(':')[-1].strip()
   try:
     nn_rpc_client_port = int(port_str)

ambari-server/src/main/resources/stacks/HDP/3.0/hooks/before-START/scripts/params.py

@@ -311,12 +311,11 @@ if dfs_ha_enabled:
      namenode_rpc = nn_host
    pass
  pass
-elif 'dfs.namenode.rpc-address' in config['configurations']['hdfs-site']:
-  namenode_rpc = default('/configurations/hdfs-site/dfs.namenode.rpc-address', None)
 else:
-  namenode_rpc = default_fs
+  namenode_rpc = default('/configurations/hdfs-site/dfs.namenode.rpc-address', default_fs)
 
-if namenode_rpc:
+# if HDFS is not installed in the cluster, then don't try to access namenode_rpc
+if "core-site" in config['configurations'] and namenode_rpc:
   port_str = namenode_rpc.split(':')[-1].strip()
   try:
     nn_rpc_client_port = int(port_str)

ambari-server/src/test/java/org/apache/ambari/server/checks/AbstractCheckDescriptorTest.java

@@ -17,125 +17,58 @@
  */
 package org.apache.ambari.server.checks;
 
-import static org.easymock.EasyMock.anyLong;
 import static org.easymock.EasyMock.anyString;
 import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.reset;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
-import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
-import org.apache.ambari.server.orm.dao.RepositoryVersionDAO;
 import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
-import org.apache.ambari.server.state.RepositoryType;
 import org.apache.ambari.server.state.Service;
-import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
 import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckType;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
+import org.apache.hadoop.metrics2.sink.relocated.google.common.collect.Sets;
 import org.easymock.EasyMock;
-import org.junit.Assert;
+import org.easymock.EasyMockSupport;
+import org.easymock.Mock;
+import org.junit.Before;
 import org.junit.Test;
 
 import com.google.inject.Provider;
 
+import junit.framework.Assert;
+
 /**
  * Unit tests for AbstractCheckDescriptor
  */
-public class AbstractCheckDescriptorTest {
-  final private Clusters clusters = EasyMock.createNiceMock(Clusters.class);
-  private final RepositoryVersionDAO repositoryVersionDao = EasyMock.createNiceMock(RepositoryVersionDAO.class);
-
-  @UpgradeCheck(
-      group = UpgradeCheckGroup.DEFAULT,
-      order = 1.0f,
-      required = { UpgradeType.ROLLING, UpgradeType.NON_ROLLING, UpgradeType.HOST_ORDERED })
-  private class TestCheckImpl extends AbstractCheckDescriptor {
-    private PrereqCheckType m_type;
-
-    TestCheckImpl(PrereqCheckType type) {
-      super(null);
-      m_type = type;
-
-      clustersProvider = new Provider<Clusters>() {
-        @Override
-        public Clusters get() {
-          return clusters;
-        }
-      };
-
-      repositoryVersionDaoProvider = new Provider<RepositoryVersionDAO>() {
-        @Override
-        public RepositoryVersionDAO get() {
-          return repositoryVersionDao;
-        }
-      };
-    }
-
-    @Override
-    public PrereqCheckType getType() {
-      return m_type;
-    }
-
-    @Override
-    public void perform(PrerequisiteCheck prerequisiteCheck,
-        PrereqCheckRequest request) throws AmbariException {
-    }
-  }
-
-  @UpgradeCheck(group = UpgradeCheckGroup.DEFAULT, order = 1.0f, required = { UpgradeType.ROLLING })
-  private class RollingTestCheckImpl extends AbstractCheckDescriptor {
-    private PrereqCheckType m_type;
-
-    RollingTestCheckImpl(PrereqCheckType type) {
-      super(null);
-      m_type = type;
-
-      clustersProvider = new Provider<Clusters>() {
-        @Override
-        public Clusters get() {
-          return clusters;
-        }
-      };
-    }
-
-    @Override
-    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
-        throws AmbariException {
-    }
-  }
+public class AbstractCheckDescriptorTest extends EasyMockSupport {
+  @Mock
+  private Clusters clusters;
 
-  @UpgradeCheck(group = UpgradeCheckGroup.DEFAULT, order = 1.0f)
-  private class NotRequiredCheckTest extends AbstractCheckDescriptor {
-    private PrereqCheckType m_type;
-
-    NotRequiredCheckTest(PrereqCheckType type) {
-      super(null);
-      m_type = type;
+  /**
+   * Used to mock out what services will be provided to us by the VDF/cluster.
+   */
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
 
-      clustersProvider = new Provider<Clusters>() {
-        @Override
-        public Clusters get() {
-          return clusters;
-        }
-      };
-    }
+  /**
+   *
+   */
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
 
-    @Override
-    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
-        throws AmbariException {
-    }
+  @Before
+  public void setup() throws Exception {
+    injectMocks(this);
   }
 
   @Test
@@ -169,7 +102,7 @@ public class AbstractCheckDescriptorTest {
   @Test
   public void testIsApplicable() throws Exception{
     final String clusterName = "c1";
-    final Cluster cluster = EasyMock.createMock(Cluster.class);
+    final Cluster cluster = createMock(Cluster.class);
 
 
     Map<String, Service> services = new HashMap<String, Service>(){{
@@ -178,88 +111,88 @@ public class AbstractCheckDescriptorTest {
       put("SERVICE3", null);
     }};
 
+    Set<String> oneServiceList = Sets.newHashSet("SERVICE1");
+    Set<String> atLeastOneServiceList = Sets.newHashSet("SERVICE1", "MISSING_SERVICE");
+    Set<String> allServicesList = Sets.newHashSet("SERVICE1", "SERVICE2");
+    Set<String> missingServiceList = Sets.newHashSet("MISSING_SERVICE");
+
     expect(clusters.getCluster(anyString())).andReturn(cluster).atLeastOnce();
     expect(cluster.getServices()).andReturn(services).atLeastOnce();
 
-    replay(clusters, cluster);
-
-    AbstractCheckDescriptor check = new TestCheckImpl(PrereqCheckType.SERVICE);
-    PrereqCheckRequest request = new PrereqCheckRequest(clusterName, UpgradeType.ROLLING);
-
-    List<String> oneServiceList = Arrays.asList("SERVICE1");
+    RepositoryVersionEntity repositoryVersion = createNiceMock(RepositoryVersionEntity.class);
+    expect(repositoryVersion.getRepositoryXml()).andReturn(m_vdfXml).atLeastOnce();
+    expect(m_vdfXml.getClusterSummary(EasyMock.anyObject(Cluster.class))).andReturn(
+        m_clusterVersionSummary).atLeastOnce();
 
-    List<String> atLeastOneServiceList = Arrays.asList("SERVICE1", "NON_EXISTED_SERVICE");
+    expect(m_clusterVersionSummary.getAvailableServiceNames()).andReturn(
+        allServicesList).atLeastOnce();
 
-    List<String> allServicesList = Arrays.asList("SERVICE1", "SERVICE2");
 
-    List<String> nonExistedList = Arrays.asList("NON_EXISTED_SERVICE");
+    replayAll();
 
+    TestCheckImpl check = new TestCheckImpl(PrereqCheckType.SERVICE);
+    PrereqCheckRequest request = new PrereqCheckRequest(clusterName, UpgradeType.ROLLING);
+    request.setTargetRepositoryVersion(repositoryVersion);
 
     // case, where we need at least one service to be present
-    Assert.assertEquals(true, check.isApplicable(request, oneServiceList, false));
-    Assert.assertEquals(true, check.isApplicable(request, atLeastOneServiceList, false));
+    check.setApplicableServices(oneServiceList);
+    Assert.assertTrue(check.isApplicable(request));
 
-    // case, where all services need to be present
-    Assert.assertEquals(false, check.isApplicable(request,atLeastOneServiceList, true));
-    Assert.assertEquals(true, check.isApplicable(request, allServicesList, true));
+    check.setApplicableServices(atLeastOneServiceList);
+    Assert.assertTrue(check.isApplicable(request));
 
-    // Case with empty list of the required services
-    Assert.assertEquals(false, check.isApplicable(request, new ArrayList<String>(), true));
-    Assert.assertEquals(false, check.isApplicable(request, new ArrayList<String>(), false));
-
-    // Case with non existed services
-    Assert.assertEquals(false, check.isApplicable(request, nonExistedList, false));
-    Assert.assertEquals(false, check.isApplicable(request, nonExistedList, true));
+    check.setApplicableServices(missingServiceList);
+    Assert.assertFalse(check.isApplicable(request));
   }
 
+  /**
+   * Tests that even though the services are installed, the check doesn't match
+   * since it's for a service not in the PATCH.
+   *
+   * @throws Exception
+   */
   @Test
-  public void testIsApplicableWithVDF() throws Exception{
+  public void testIsApplicableForPatch() throws Exception {
     final String clusterName = "c1";
-    final Cluster cluster = EasyMock.createMock(Cluster.class);
+    final Cluster cluster = createMock(Cluster.class);
 
-    Map<String, Service> services = new HashMap<String, Service>(){{
-      put("SERVICE1", null);
-      put("SERVICE2", null);
-      put("SERVICE3", null);
-    }};
+    Map<String, Service> services = new HashMap<String, Service>() {
+      {
+        put("SERVICE1", null);
+        put("SERVICE2", null);
+        put("SERVICE3", null);
+      }
+    };
+
+    Set<String> oneServiceList = Sets.newHashSet("SERVICE1");
 
     expect(clusters.getCluster(anyString())).andReturn(cluster).atLeastOnce();
     expect(cluster.getServices()).andReturn(services).atLeastOnce();
 
-    RepositoryVersionEntity repoVersion = EasyMock.createMock(RepositoryVersionEntity.class);
-    VersionDefinitionXml repoXml = EasyMock.createMock(VersionDefinitionXml.class);
-    expect(repoVersion.getType()).andReturn(RepositoryType.PATCH).atLeastOnce();
-    expect(repoVersion.getRepositoryXml()).andReturn(repoXml).atLeastOnce();
-    expect(repoVersion.getStackId()).andReturn(new StackId("HDP-2.5")).atLeastOnce();
-    expect(repoVersion.getVersion()).andReturn("2.5.0.0-1234").atLeastOnce();
-    expect(repoXml.getAvailableServiceNames()).andReturn(Collections.singleton("SERVICE2")).atLeastOnce();
+    RepositoryVersionEntity repositoryVersion = createNiceMock(RepositoryVersionEntity.class);
+    expect(repositoryVersion.getRepositoryXml()).andReturn(m_vdfXml).atLeastOnce();
+    expect(m_vdfXml.getClusterSummary(EasyMock.anyObject(Cluster.class))).andReturn(
+        m_clusterVersionSummary).atLeastOnce();
 
-    expect(repositoryVersionDao.findByPK(anyLong())).andReturn(repoVersion).atLeastOnce();
+    // the cluster summary will only return 1 service for the upgrade, even
+    // though this cluster has 2 services installed
+    expect(m_clusterVersionSummary.getAvailableServiceNames()).andReturn(
+        oneServiceList).atLeastOnce();
 
-    expect(repositoryVersionDao.findByStackNameAndVersion(anyString(), anyString())).andReturn(
-        repoVersion).atLeastOnce();
+    replayAll();
 
-    replay(clusters, cluster, repositoryVersionDao, repoVersion, repoXml);
-
-    AbstractCheckDescriptor check = new TestCheckImpl(PrereqCheckType.SERVICE);
+    TestCheckImpl check = new TestCheckImpl(PrereqCheckType.SERVICE);
     PrereqCheckRequest request = new PrereqCheckRequest(clusterName, UpgradeType.ROLLING);
-    request.setTargetRepositoryVersion(repoVersion);
-
-    List<String> allServicesList = Arrays.asList("SERVICE1", "SERVICE2");
-
-    // SERVICE2 is the only thing in VDF
-    Assert.assertEquals(true, check.isApplicable(request, allServicesList, false));
+    request.setTargetRepositoryVersion(repositoryVersion);
 
-    List<String> oneServicesList = Arrays.asList("SERVICE1");
+    // since the check is for SERVICE2, it should not match even though its
+    // installed since the repository is only for SERVICE1
+    check.setApplicableServices(Sets.newHashSet("SERVICE2"));
+    Assert.assertFalse(check.isApplicable(request));
 
-    // SERVICE2 is the only thing in VDF, a check for only SERVICE1 fail
-    Assert.assertEquals(false, check.isApplicable(request, oneServicesList, false));
-
-    // a VDF without available services is technically invalid, so expect any passed services to return false
-    reset(repoXml);
-    expect(repoXml.getAvailableServiceNames()).andReturn(Collections.<String>emptySet()).atLeastOnce();
-    replay(repoXml);
-    Assert.assertEquals(false, check.isApplicable(request, allServicesList, false));
+    // ok, so now change the check to match against SERVICE1
+    check.setApplicableServices(Sets.newHashSet("SERVICE1"));
+    Assert.assertTrue(check.isApplicable(request));
   }
 
   /**
@@ -284,4 +217,90 @@ public class AbstractCheckDescriptorTest {
     Assert.assertTrue(requiredCheck.isRequired(UpgradeType.HOST_ORDERED));
   }
 
-}
+  @UpgradeCheck(
+      group = UpgradeCheckGroup.DEFAULT,
+      order = 1.0f,
+      required = { UpgradeType.ROLLING, UpgradeType.NON_ROLLING, UpgradeType.HOST_ORDERED })
+  private class TestCheckImpl extends AbstractCheckDescriptor {
+    private PrereqCheckType m_type;
+    private Set<String> m_applicableServices = Sets.newHashSet();
+
+    TestCheckImpl(PrereqCheckType type) {
+      super(null);
+      m_type = type;
+
+      clustersProvider = new Provider<Clusters>() {
+        @Override
+        public Clusters get() {
+          return clusters;
+        }
+      };
+    }
+
+    @Override
+    public PrereqCheckType getType() {
+      return m_type;
+    }
+
+    @Override
+    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+        throws AmbariException {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Set<String> getApplicableServices() {
+      return m_applicableServices;
+    }
+
+    void setApplicableServices(Set<String> applicableServices) {
+      m_applicableServices = applicableServices;
+    }
+  }
+
+  @UpgradeCheck(group = UpgradeCheckGroup.DEFAULT, order = 1.0f, required = { UpgradeType.ROLLING })
+  private class RollingTestCheckImpl extends AbstractCheckDescriptor {
+    private PrereqCheckType m_type;
+
+    RollingTestCheckImpl(PrereqCheckType type) {
+      super(null);
+      m_type = type;
+
+      clustersProvider = new Provider<Clusters>() {
+        @Override
+        public Clusters get() {
+          return clusters;
+        }
+      };
+    }
+
+    @Override
+    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+        throws AmbariException {
+    }
+  }
+
+  @UpgradeCheck(group = UpgradeCheckGroup.DEFAULT, order = 1.0f)
+  private class NotRequiredCheckTest extends AbstractCheckDescriptor {
+    private PrereqCheckType m_type;
+
+    NotRequiredCheckTest(PrereqCheckType type) {
+      super(null);
+      m_type = type;
+
+      clustersProvider = new Provider<Clusters>() {
+        @Override
+        public Clusters get() {
+          return clusters;
+        }
+      };
+    }
+
+    @Override
+    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+        throws AmbariException {
+    }
+  }
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ClientRetryPropertyCheckTest.java

@@ -22,7 +22,6 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
-import org.apache.ambari.server.orm.dao.RepositoryVersionDAO;
 import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
@@ -30,32 +29,45 @@ import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /**
  * Tests for {@link ClientRetryPropertyCheckTest}
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ClientRetryPropertyCheckTest {
   private final Clusters m_clusters = Mockito.mock(Clusters.class);
 
   private final ClientRetryPropertyCheck m_check = new ClientRetryPropertyCheck();
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
-  private final RepositoryVersionDAO repositoryVersionDAO = Mockito.mock(
-      RepositoryVersionDAO.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     m_check.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -68,6 +80,11 @@ public class ClientRetryPropertyCheckTest {
 
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.3.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.3"));
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   /**
@@ -79,8 +96,7 @@ public class ClientRetryPropertyCheckTest {
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(m_clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Map<String, Service> services = new HashMap<>();
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
 
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
     request.setTargetRepositoryVersion(m_repositoryVersion);
@@ -88,23 +104,13 @@ public class ClientRetryPropertyCheckTest {
     // nothing installed
     Assert.assertFalse(m_check.isApplicable(request));
 
-    m_check.repositoryVersionDaoProvider = new Provider<RepositoryVersionDAO>() {
-      @Override
-      public RepositoryVersionDAO get() {
-        return repositoryVersionDAO;
-      }
-    };
-
-    Mockito.when(repositoryVersionDAO.findByStackNameAndVersion(Mockito.anyString(),
-        Mockito.anyString())).thenReturn(m_repositoryVersion);
-
     // HDFS installed
-    services.put("HDFS", Mockito.mock(Service.class));
+    m_services.put("HDFS", Mockito.mock(Service.class));
     Assert.assertTrue(m_check.isApplicable(request));
 
     // OOZIE installed
-    services.clear();
-    services.put("OOZIE", Mockito.mock(Service.class));
+    m_services.clear();
+    m_services.put("OOZIE", Mockito.mock(Service.class));
     Assert.assertTrue(m_check.isApplicable(request));
   }
 
@@ -182,4 +188,4 @@ public class ClientRetryPropertyCheckTest {
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
   }
-}
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ComponentExistsInRepoCheckTest.java

@@ -0,0 +1,352 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.ambari.server.checks;
+
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.expect;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.ambari.server.StackAccessException;
+import org.apache.ambari.server.api.services.AmbariMetaInfo;
+import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
+import org.apache.ambari.server.state.Cluster;
+import org.apache.ambari.server.state.Clusters;
+import org.apache.ambari.server.state.ComponentInfo;
+import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.ServiceComponent;
+import org.apache.ambari.server.state.ServiceInfo;
+import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
+import org.apache.ambari.server.state.stack.PrereqCheckStatus;
+import org.apache.ambari.server.state.stack.PrerequisiteCheck;
+import org.apache.commons.lang.StringUtils;
+import org.easymock.EasyMockSupport;
+import org.easymock.Mock;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.inject.Provider;
+
+/**
+ * Tests for {@link ComponentsExistInRepoCheck}
+ */
+public class ComponentExistsInRepoCheckTest extends EasyMockSupport {
+
+  private final ComponentsExistInRepoCheck m_check = new ComponentsExistInRepoCheck();
+
+  @Mock
+  private Clusters m_clusters;
+
+  @Mock
+  private Cluster m_cluster;
+
+  // pick two stacks which have different services
+  private final StackId SOURCE_STACK = new StackId("HDP", "0.1");
+  private final StackId TARGET_STACK = new StackId("HDP", "2.2.0");
+
+  private final Map<String, Service> CLUSTER_SERVICES = new HashMap<>();
+  private final Map<String, ServiceComponent> FOO_SERVICE_COMPONENTS = new HashMap<>();
+  private final Map<String, ServiceComponent> ZK_SERVICE_COMPONENTS = new HashMap<>();
+
+  @Mock
+  private AmbariMetaInfo m_ambariMetaInfo;
+
+  @Mock
+  private Service m_fooService;
+
+  @Mock
+  private Service m_zookeeperService;
+
+  @Mock
+  private ServiceInfo m_fooInfo;
+
+  @Mock
+  private ServiceInfo m_zookeeperInfo;
+
+  @Mock
+  private ComponentInfo m_fooComponentInfo;
+
+  @Mock
+  private ComponentInfo m_zookeeperServerInfo;
+
+  @Mock
+  private ServiceComponent m_fooComponent;
+
+  @Mock
+  private ServiceComponent m_zookeeperServer;
+
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  @Before
+  public void before() throws Exception {
+
+    EasyMockSupport.injectMocks(this);
+
+    m_check.clustersProvider = new Provider<Clusters>() {
+      @Override
+      public Clusters get() {
+        return m_clusters;
+      }
+    };
+
+    m_check.ambariMetaInfo = new Provider<AmbariMetaInfo>() {
+      @Override
+      public AmbariMetaInfo get() {
+        return m_ambariMetaInfo;
+      }
+    };
+
+    expect(m_cluster.getServices()).andReturn(CLUSTER_SERVICES).atLeastOnce();
+    expect(m_cluster.getService("ZOOKEEPER")).andReturn(m_zookeeperService).anyTimes();
+    expect(m_cluster.getService("FOO_SERVICE")).andReturn(m_fooService).anyTimes();
+
+    expect(m_clusters.getCluster((String) anyObject())).andReturn(m_cluster).anyTimes();
+
+    ZK_SERVICE_COMPONENTS.put("ZOOKEEPER_SERVER", m_zookeeperServer);
+    FOO_SERVICE_COMPONENTS.put("FOO_COMPONENT", m_fooComponent);
+
+    expect(m_zookeeperService.getServiceComponents()).andReturn(ZK_SERVICE_COMPONENTS).anyTimes();
+    expect(m_fooService.getServiceComponents()).andReturn(FOO_SERVICE_COMPONENTS).anyTimes();
+
+    expect(m_zookeeperInfo.getComponentByName("ZOOKEEPER_SERVER")).andReturn(
+        m_zookeeperServerInfo).anyTimes();
+
+    expect(m_fooInfo.getComponentByName("FOO_COMPONENT")).andReturn(m_fooComponentInfo).anyTimes();
+
+    expect(m_ambariMetaInfo.getService(TARGET_STACK.getStackName(), TARGET_STACK.getStackVersion(),
+        "ZOOKEEPER")).andReturn(m_zookeeperInfo).anyTimes();
+
+    expect(m_ambariMetaInfo.getComponent(TARGET_STACK.getStackName(),
+        TARGET_STACK.getStackVersion(), "ZOOKEEPER", "ZOOKEEPER_SERVER")).andReturn(
+            m_zookeeperServerInfo).anyTimes();
+
+    expect(m_repositoryVersion.getStackId()).andReturn(TARGET_STACK).anyTimes();
+    expect(m_repositoryVersion.getVersion()).andReturn("2.2.0").anyTimes();
+
+    expect(m_repositoryVersion.getRepositoryXml()).andReturn(m_vdfXml).anyTimes();
+    expect(m_vdfXml.getClusterSummary(anyObject(Cluster.class))).andReturn(m_clusterVersionSummary).anyTimes();
+    expect(m_clusterVersionSummary.getAvailableServiceNames()).andReturn(CLUSTER_SERVICES.keySet()).anyTimes();
+
+  }
+
+  /**
+   * Tests that the check passes when services and components exist.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckPassesWhenServicAndComponentsExist() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("ZOOKEEPER", m_zookeeperService);
+    expect(m_zookeeperInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperInfo.isDeleted()).andReturn(false).atLeastOnce();
+    expect(m_zookeeperServerInfo.isVersionAdvertised()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperServerInfo.isDeleted()).andReturn(false).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
+    Assert.assertTrue(StringUtils.isBlank(check.getFailReason()));
+  }
+
+  /**
+   * Tests that the check passes when a service doesn't exist but isn't
+   * advertising its version.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckPassesWhenComponentNotAdvertisingVersion() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("FOO_SERVICE", m_fooService);
+
+    expect(m_ambariMetaInfo.getService(TARGET_STACK.getStackName(), TARGET_STACK.getStackVersion(),
+        "FOO_SERVICE")).andReturn(m_fooInfo).anyTimes();
+
+    expect(m_ambariMetaInfo.getComponent(TARGET_STACK.getStackName(),
+        TARGET_STACK.getStackVersion(), "FOO_SERVICE", "FOO_COMPONENT")).andReturn(
+            m_fooComponentInfo).atLeastOnce();
+
+    expect(m_fooInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_fooInfo.isDeleted()).andReturn(false).atLeastOnce();
+    expect(m_fooComponentInfo.isVersionAdvertised()).andReturn(false).atLeastOnce();
+    expect(m_fooComponentInfo.isDeleted()).andReturn(true).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
+    Assert.assertTrue(StringUtils.isBlank(check.getFailReason()));
+  }
+
+  /**
+   * Tests that the check fails when the service exists but was deleted.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckFailsWhenServiceExistsButIsDeleted() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("ZOOKEEPER", m_zookeeperService);
+    expect(m_zookeeperInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperInfo.isDeleted()).andReturn(true).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
+    Assert.assertTrue(check.getFailedOn().contains("ZOOKEEPER"));
+  }
+
+  /**
+   * Tests that the check fails when the component exists but what deleted.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckFailsWhenComponentExistsButIsDeleted() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("ZOOKEEPER", m_zookeeperService);
+    expect(m_zookeeperInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperInfo.isDeleted()).andReturn(false).atLeastOnce();
+    expect(m_zookeeperServerInfo.isVersionAdvertised()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperServerInfo.isDeleted()).andReturn(true).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
+    Assert.assertTrue(check.getFailedOn().contains("ZOOKEEPER_SERVER"));
+  }
+
+  /**
+   * Tests that the check fails when the component exists but what deleted.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckFailsWhenServiceIsMissing() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(
+        CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("ZOOKEEPER", m_zookeeperService);
+    CLUSTER_SERVICES.put("FOO_SERVICE", m_fooService);
+
+    expect(m_ambariMetaInfo.getService(TARGET_STACK.getStackName(), TARGET_STACK.getStackVersion(),
+        "FOO_SERVICE")).andThrow(new StackAccessException(""));
+
+    expect(m_zookeeperInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperInfo.isDeleted()).andReturn(false).atLeastOnce();
+    expect(m_zookeeperServerInfo.isVersionAdvertised()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperServerInfo.isDeleted()).andReturn(false).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
+    Assert.assertTrue(check.getFailedOn().contains("FOO_SERVICE"));
+  }
+
+  /**
+   * Tests that the check fails when the component exists but what deleted.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testCheckFailsWhenComponentIsMissing() throws Exception {
+    PrerequisiteCheck check = new PrerequisiteCheck(
+        CheckDescription.COMPONENTS_EXIST_IN_TARGET_REPO, "c1");
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setSourceStackId(SOURCE_STACK);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    CLUSTER_SERVICES.put("FOO_SERVICE", m_fooService);
+
+    expect(m_ambariMetaInfo.getService(TARGET_STACK.getStackName(), TARGET_STACK.getStackVersion(),
+        "FOO_SERVICE")).andReturn(m_fooInfo).anyTimes();
+
+    expect(m_ambariMetaInfo.getComponent(TARGET_STACK.getStackName(),
+        TARGET_STACK.getStackVersion(), "FOO_SERVICE", "FOO_COMPONENT")).andThrow(
+            new StackAccessException(""));
+
+    expect(m_zookeeperInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperInfo.isDeleted()).andReturn(false).atLeastOnce();
+    expect(m_zookeeperServerInfo.isVersionAdvertised()).andReturn(true).atLeastOnce();
+    expect(m_zookeeperServerInfo.isDeleted()).andReturn(false).atLeastOnce();
+
+    expect(m_fooInfo.isValid()).andReturn(true).atLeastOnce();
+    expect(m_fooInfo.isDeleted()).andReturn(false).atLeastOnce();
+
+    replayAll();
+
+    Assert.assertTrue(m_check.isApplicable(request));
+
+    m_check.perform(check, request);
+
+    Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
+    Assert.assertTrue(check.getFailedOn().contains("FOO_COMPONENT"));
+  }
+
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ComponentsInstallationCheckTest.java

@@ -37,13 +37,17 @@ import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.ServiceComponent;
 import org.apache.ambari.server.state.StackId;
 import org.apache.ambari.server.state.State;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.powermock.api.mockito.PowerMockito;
@@ -63,15 +67,30 @@ public class ComponentsInstallationCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private AmbariMetaInfo ambariMetaInfo = Mockito.mock(AmbariMetaInfo.class);
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
+    MockitoAnnotations.initMocks(this);
+
+    m_services.clear();
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.2.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2"));
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
@@ -118,10 +137,9 @@ public class ComponentsInstallationCheckTest {
     Mockito.when(tezService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
     Mockito.when(amsService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
 
-    HashMap<String, Service> clusterServices = new HashMap<>();
-    clusterServices.put("HDFS", hdfsService);
-    clusterServices.put("TEZ", tezService);
-    clusterServices.put("AMBARI_METRICS", amsService);
+    m_services.put("HDFS", hdfsService);
+    m_services.put("TEZ", tezService);
+    m_services.put("AMBARI_METRICS", amsService);
 
     Mockito.when(hdfsService.getName()).thenReturn("HDFS");
     Mockito.when(tezService.getName()).thenReturn("TEZ");
@@ -131,7 +149,11 @@ public class ComponentsInstallationCheckTest {
     Mockito.when(tezService.isClientOnlyService()).thenReturn(true);
     Mockito.when(amsService.isClientOnlyService()).thenReturn(false);
 
-    Mockito.when(cluster.getServices()).thenReturn(clusterServices);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
+
+    Mockito.when(cluster.getService("HDFS")).thenReturn(hdfsService);
+    Mockito.when(cluster.getService("TEZ")).thenReturn(tezService);
+    Mockito.when(cluster.getService("AMBARI_METRICS")).thenReturn(amsService);
 
     Mockito.when(ambariMetaInfo.getComponent(Mockito.anyString(), Mockito.anyString(),
         Mockito.anyString(), Mockito.anyString())).thenAnswer(new Answer<ComponentInfo>() {
@@ -260,22 +282,26 @@ public class ComponentsInstallationCheckTest {
       Mockito.when(hcs.getDesiredState()).thenReturn(State.INSTALLED);
       Mockito.when(hcs.getCurrentState()).thenReturn(State.STARTED);
     }
+
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
     Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALLED);
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
-    componentsInstallationCheck.perform(check, new PrereqCheckRequest("cluster"));
+    componentsInstallationCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 2. Ensure that AMS is ignored even if their current state is not INSTALLED
     Mockito.when(hcsMetricsCollector.getCurrentState()).thenReturn(State.INSTALL_FAILED);
     Mockito.when(hcsMetricsMonitor.getCurrentState()).thenReturn(State.INSTALL_FAILED);
     check = new PrerequisiteCheck(null, null);
-    componentsInstallationCheck.perform(check, new PrereqCheckRequest("cluster"));
+    componentsInstallationCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 3: Change TEZ client state to INSTALL_FAILED, should fail
     Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
     check = new PrerequisiteCheck(null, null);
-    componentsInstallationCheck.perform(check, new PrereqCheckRequest("cluster"));
+    componentsInstallationCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
     Assert.assertTrue(check.getFailReason().indexOf("Service components in INSTALL_FAILED state") > -1);
 
@@ -283,7 +309,7 @@ public class ComponentsInstallationCheckTest {
     Mockito.when(tezService.getMaintenanceState()).thenReturn(MaintenanceState.ON);
     Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
     check = new PrerequisiteCheck(null, null);
-    componentsInstallationCheck.perform(check, new PrereqCheckRequest("cluster"));
+    componentsInstallationCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 5: Change TEZ client state to INSTALL_FAILED and place host2 in Maintenance mode, should succeed
@@ -291,7 +317,7 @@ public class ComponentsInstallationCheckTest {
     Mockito.when(host2.getMaintenanceState(1L)).thenReturn(MaintenanceState.ON);
     Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
     check = new PrerequisiteCheck(null, null);
-    componentsInstallationCheck.perform(check, new PrereqCheckRequest("cluster"));
+    componentsInstallationCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
   }
 }

ambari-server/src/test/java/org/apache/ambari/server/checks/HiveDynamicServiceDiscoveryCheckTest.java

@@ -52,7 +52,7 @@ public class HiveDynamicServiceDiscoveryCheckTest {
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     m_check.clustersProvider = new Provider<Clusters>() {
 
       @Override

ambari-server/src/test/java/org/apache/ambari/server/checks/HiveMultipleMetastoreCheckTest.java

@@ -31,31 +31,46 @@ import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.ServiceComponent;
 import org.apache.ambari.server.state.ServiceComponentHost;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /**
  * Tests {@link HiveMultipleMetastoreCheck}
  */
+@RunWith(MockitoJUnitRunner.class)
 public class HiveMultipleMetastoreCheckTest {
   private final Clusters m_clusters = Mockito.mock(Clusters.class);
   private final HiveMultipleMetastoreCheck m_check = new HiveMultipleMetastoreCheck();
   private final RepositoryVersionDAO repositoryVersionDAO = Mockito.mock(
       RepositoryVersionDAO.class);
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     m_check.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -68,6 +83,11 @@ public class HiveMultipleMetastoreCheckTest {
 
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   /**
@@ -81,10 +101,9 @@ public class HiveMultipleMetastoreCheckTest {
 
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(m_clusters.getCluster("cluster")).thenReturn(cluster);
-    Map<String, Service> services = new HashMap<>();
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
 
-    services.put("HDFS", Mockito.mock(Service.class));
+    m_services.put("HDFS", Mockito.mock(Service.class));
 
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
     request.setTargetRepositoryVersion(m_repositoryVersion);
@@ -93,7 +112,7 @@ public class HiveMultipleMetastoreCheckTest {
     Assert.assertFalse(m_check.isApplicable(request));
 
     // install HIVE
-    services.put("HIVE", Mockito.mock(Service.class));
+    m_services.put("HIVE", Mockito.mock(Service.class));
 
     m_check.repositoryVersionDaoProvider = new Provider<RepositoryVersionDAO>() {
       @Override

ambari-server/src/test/java/org/apache/ambari/server/checks/HiveNotRollingWarningTest.java

@@ -21,28 +21,57 @@ import java.util.HashMap;
 import java.util.Map;
 
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockSupport;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /**
  * Tests {@link HiveNotRollingWarning}.
  */
+@RunWith(MockitoJUnitRunner.class)
 public class HiveNotRollingWarningTest extends EasyMockSupport {
 
   private final String m_clusterName = "c1";
   private final Clusters m_clusters = niceMock(Clusters.class);
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
+  @Before
+  public void setup() throws Exception {
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
+  }
+
+
   /**
    * @throws Exception
    */
@@ -60,18 +89,18 @@ public class HiveNotRollingWarningTest extends EasyMockSupport {
     final Cluster cluster = niceMock(Cluster.class);
     final Service hive = niceMock(Service.class);
 
-    final Map<String, Service> services = new HashMap<>();
-    services.put("HIVE", hive);
+    m_services.put("HIVE", hive);
 
     EasyMock.expect(cluster.getClusterId()).andReturn(1L).anyTimes();
 
     EasyMock.expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP", "2.3")).anyTimes();
-    EasyMock.expect(cluster.getServices()).andReturn(services).atLeastOnce();
+    EasyMock.expect(cluster.getServices()).andReturn(m_services).anyTimes();
     EasyMock.expect(m_clusters.getCluster(m_clusterName)).andReturn(cluster).atLeastOnce();
 
     PrereqCheckRequest request = niceMock(PrereqCheckRequest.class);
-    EasyMock.expect(request.getClusterName()).andReturn(m_clusterName);
-    EasyMock.expect(request.getUpgradeType()).andReturn(UpgradeType.ROLLING);
+    EasyMock.expect(request.getClusterName()).andReturn(m_clusterName).anyTimes();
+    EasyMock.expect(request.getUpgradeType()).andReturn(UpgradeType.ROLLING).anyTimes();
+    EasyMock.expect(request.getTargetRepositoryVersion()).andReturn(m_repositoryVersion).atLeastOnce();
 
     replayAll();
 

ambari-server/src/test/java/org/apache/ambari/server/checks/HostsHeartbeatCheckTest.java

@@ -52,7 +52,7 @@ public class HostsHeartbeatCheckTest {
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.2.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2"));
   }

ambari-server/src/test/java/org/apache/ambari/server/checks/HostsMasterMaintenanceCheckTest.java

@@ -30,6 +30,8 @@ import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Host;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack;
@@ -37,8 +39,12 @@ import org.apache.ambari.server.state.stack.UpgradePack.ProcessingComponent;
 import org.apache.ambari.server.state.stack.upgrade.RepositoryVersionHelper;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -46,22 +52,39 @@ import com.google.inject.Provider;
  * Unit tests for HostsMasterMaintenanceCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class HostsMasterMaintenanceCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private final RepositoryVersionDAO repositoryVersionDAO = Mockito.mock(RepositoryVersionDAO.class);
   private final RepositoryVersionHelper repositoryVersionHelper = Mockito.mock(RepositoryVersionHelper.class);
   private final AmbariMetaInfo ambariMetaInfo = Mockito.mock(AmbariMetaInfo.class);
 
-  final RepositoryVersionEntity repositoryVersion = Mockito.mock(
-      RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
+  @Before
+  public void setup() throws Exception {
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
+  }
 
   @Test
   public void testIsApplicable() throws Exception {
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
 
     final PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setTargetRepositoryVersion(repositoryVersion);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
     HostsMasterMaintenanceCheck hmmc = new HostsMasterMaintenanceCheck();
     Configuration config = Mockito.mock(Configuration.class);
     hmmc.config = config;
@@ -71,19 +94,13 @@ public class HostsMasterMaintenanceCheckTest {
     HostsMasterMaintenanceCheck hmmc2 = new HostsMasterMaintenanceCheck();
     hmmc2.config = config;
     Assert.assertTrue(hmmc2.isApplicable(request));
-    request.setTargetRepositoryVersion(repositoryVersion);
-
-    // reset the mock
-    Mockito.reset(repositoryVersion);
-
-    hmmc2.config = config;
-    Assert.assertFalse(hmmc2.isApplicable(request));
+    request.setTargetRepositoryVersion(m_repositoryVersion);
   }
 
   @Test
   public void testPerform() throws Exception {
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
 
     final String upgradePackName = "upgrade_pack";
     final HostsMasterMaintenanceCheck hostsMasterMaintenanceCheck = new HostsMasterMaintenanceCheck();
@@ -120,21 +137,22 @@ public class HostsMasterMaintenanceCheckTest {
     Mockito.when(repositoryVersionHelper.getUpgradePackageName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), (UpgradeType) Mockito.anyObject())).thenReturn(null);
 
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
-    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-1.0"));
-    request.setTargetRepositoryVersion(repositoryVersion);
-    hostsMasterMaintenanceCheck.perform(check, request);
+    PrereqCheckRequest checkRequest = new PrereqCheckRequest("cluster");
+    checkRequest.setSourceStackId(new StackId("HDP-1.0"));
+    checkRequest.setTargetRepositoryVersion(m_repositoryVersion);
+
+    hostsMasterMaintenanceCheck.perform(check, checkRequest);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
 
     Mockito.when(repositoryVersionHelper.getUpgradePackageName(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), (UpgradeType) Mockito.anyObject())).thenReturn(upgradePackName);
     Mockito.when(ambariMetaInfo.getUpgradePacks(Mockito.anyString(), Mockito.anyString())).thenReturn(new HashMap<String, UpgradePack>());
 
     check = new PrerequisiteCheck(null, null);
-    request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-1.0"));
-    request.setTargetRepositoryVersion(repositoryVersion);
+    checkRequest = new PrereqCheckRequest("cluster");
+    checkRequest.setSourceStackId(new StackId("HDP-1.0"));
+    checkRequest.setTargetRepositoryVersion(m_repositoryVersion);
 
-    hostsMasterMaintenanceCheck.perform(check, request);
+    hostsMasterMaintenanceCheck.perform(check, checkRequest);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
 
     final Map<String, UpgradePack> upgradePacks = new HashMap<>();
@@ -147,11 +165,11 @@ public class HostsMasterMaintenanceCheckTest {
     Mockito.when(clusters.getHostsForCluster(Mockito.anyString())).thenReturn(new HashMap<String, Host>());
 
     check = new PrerequisiteCheck(null, null);
-    request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-1.0"));
-    request.setTargetRepositoryVersion(repositoryVersion);
+    checkRequest = new PrereqCheckRequest("cluster");
+    checkRequest.setSourceStackId(new StackId("HDP-1.0"));
+    checkRequest.setTargetRepositoryVersion(m_repositoryVersion);
 
-    hostsMasterMaintenanceCheck.perform(check, request);
+    hostsMasterMaintenanceCheck.perform(check, checkRequest);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
   }
-}
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/HostsRepositoryVersionCheckTest.java

@@ -17,7 +17,6 @@
  */
 package org.apache.ambari.server.checks;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -33,13 +32,19 @@ import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Host;
 import org.apache.ambari.server.state.MaintenanceState;
 import org.apache.ambari.server.state.RepositoryVersionState;
+import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -47,23 +52,38 @@ import com.google.inject.Provider;
  * Unit tests for HostsRepositoryVersionCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class HostsRepositoryVersionCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private final HostVersionDAO hostVersionDAO = Mockito.mock(HostVersionDAO.class);
   private final RepositoryVersionDAO repositoryVersionDAO = Mockito.mock(RepositoryVersionDAO.class);
 
-  final RepositoryVersionEntity repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   @Before
-  public void setup() {
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
+  public void setup() throws Exception {
+    m_services.clear();
+
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("1.0.0.0-1234");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "1.0"));
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setTargetRepositoryVersion(repositoryVersion);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
     HostsRepositoryVersionCheck hrvc = new HostsRepositoryVersionCheck();
     Configuration config = Mockito.mock(Configuration.class);
     hrvc.config = config;
@@ -72,13 +92,6 @@ public class HostsRepositoryVersionCheckTest {
     HostsRepositoryVersionCheck hrvc2 = new HostsRepositoryVersionCheck();
     hrvc2.config = config;
     Assert.assertTrue(hrvc2.isApplicable(request));
-
-    Mockito.reset(repositoryVersion);
-    request.setTargetRepositoryVersion(repositoryVersion);
-
-    HostsMasterMaintenanceCheck hmmc2 = new HostsMasterMaintenanceCheck();
-    hmmc2.config = config;
-    Assert.assertFalse(hmmc2.isApplicable(request));
   }
 
   @Test
@@ -131,7 +144,7 @@ public class HostsRepositoryVersionCheckTest {
 
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
     PrereqCheckRequest checkRequest = new PrereqCheckRequest("cluster");
-    checkRequest.setTargetRepositoryVersion(repositoryVersion);
+    checkRequest.setTargetRepositoryVersion(m_repositoryVersion);
 
     hostsRepositoryVersionCheck.perform(check, checkRequest);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
@@ -201,22 +214,29 @@ public class HostsRepositoryVersionCheckTest {
     Mockito.when(host1.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
     Mockito.when(host2.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
     Mockito.when(host3.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
+
+    Mockito.when(host1.getHostName()).thenReturn("host1");
+    Mockito.when(host2.getHostName()).thenReturn("host2");
+    Mockito.when(host3.getHostName()).thenReturn("host3");
+
     hosts.put("host1", host1);
     hosts.put("host2", host2);
     hosts.put("host3", host3);
     Mockito.when(clusters.getHostsForCluster("cluster")).thenReturn(hosts);
 
     HostVersionEntity hve = new HostVersionEntity();
-    hve.setRepositoryVersion(repositoryVersion);
+    hve.setRepositoryVersion(m_repositoryVersion);
     hve.setState(RepositoryVersionState.INSTALLED);
 
-    Mockito.when(
-        hostVersionDAO.findByHost(Mockito.anyString())).thenReturn(
-            Collections.singletonList(hve));
+    for (String hostName : hosts.keySet()) {
+      Mockito.when(hostVersionDAO.findByClusterStackVersionAndHost("cluster",
+          m_repositoryVersion.getStackId(), m_repositoryVersion.getVersion(), hostName)).thenReturn(
+              hve);
+    }
 
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setTargetRepositoryVersion(repositoryVersion);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
     hostsRepositoryVersionCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
@@ -256,22 +276,30 @@ public class HostsRepositoryVersionCheckTest {
     Mockito.when(host1.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
     Mockito.when(host2.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
     Mockito.when(host3.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
+
+    Mockito.when(host1.getHostName()).thenReturn("host1");
+    Mockito.when(host2.getHostName()).thenReturn("host2");
+    Mockito.when(host3.getHostName()).thenReturn("host3");
+
     hosts.put("host1", host1);
     hosts.put("host2", host2);
     hosts.put("host3", host3);
     Mockito.when(clusters.getHostsForCluster("cluster")).thenReturn(hosts);
 
     HostVersionEntity hve = new HostVersionEntity();
-    hve.setRepositoryVersion(repositoryVersion);
+    hve.setRepositoryVersion(m_repositoryVersion);
     hve.setState(RepositoryVersionState.NOT_REQUIRED);
 
-    Mockito.when(
-        hostVersionDAO.findByHost(Mockito.anyString())).thenReturn(
-            Collections.singletonList(hve));
+    for (String hostName : hosts.keySet()) {
+      Mockito.when(hostVersionDAO.findByClusterStackVersionAndHost("cluster",
+          m_repositoryVersion.getStackId(), m_repositoryVersion.getVersion(), hostName)).thenReturn(
+              hve);
+    }
 
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setTargetRepositoryVersion(repositoryVersion);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
     hostsRepositoryVersionCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
   }

ambari-server/src/test/java/org/apache/ambari/server/checks/InstallPackagesCheckTest.java

@@ -72,7 +72,7 @@ public class InstallPackagesCheckTest {
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn(repositoryVersion);
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(targetStackId);
   }

ambari-server/src/test/java/org/apache/ambari/server/checks/KafkaKerberosCheckTest.java

@@ -21,26 +21,44 @@ import java.util.HashMap;
 import java.util.Map;
 
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.SecurityType;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
+@RunWith(MockitoJUnitRunner.class)
 public class KafkaKerberosCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
   private final KafkaKerberosCheck kafkaKerberosCheck = new KafkaKerberosCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     kafkaKerberosCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -48,24 +66,31 @@ public class KafkaKerberosCheckTest {
         return clusters;
       }
     };
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("KAFKA", service);
+    m_services.put("KAFKA", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(kafkaKerberosCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    Assert.assertTrue(kafkaKerberosCheck.isApplicable(request));
 
-    services.remove("KAFKA");
-    Assert.assertFalse(kafkaKerberosCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("KAFKA");
+    Assert.assertFalse(kafkaKerberosCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/MapReduce2JobHistoryStatePreservingCheckTest.java

@@ -31,31 +31,46 @@ import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.RepositoryType;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /**
  * Tests for {@link org.apache.ambari.server.checks.MapReduce2JobHistoryStatePreservingCheckTest}
  */
+@RunWith(MockitoJUnitRunner.class)
 public class MapReduce2JobHistoryStatePreservingCheckTest {
   private final Clusters m_clusters = Mockito.mock(Clusters.class);
   private final RepositoryVersionDAO m_repositoryVersionDao = Mockito.mock(RepositoryVersionDAO.class);
 
   private final MapReduce2JobHistoryStatePreservingCheck m_check = new MapReduce2JobHistoryStatePreservingCheck();
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     m_check.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -80,6 +95,11 @@ public class MapReduce2JobHistoryStatePreservingCheckTest {
 
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.3.1.1-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.3"));
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   /**
@@ -92,8 +112,7 @@ public class MapReduce2JobHistoryStatePreservingCheckTest {
     Mockito.when(m_clusters.getCluster("cluster")).thenReturn(cluster);
     Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("HDP-2.3"));
 
-    Map<String, Service> services = new HashMap<>();
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
 
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
     request.setSourceStackId(new StackId("HDP", "2.3.0.0"));
@@ -103,7 +122,7 @@ public class MapReduce2JobHistoryStatePreservingCheckTest {
     Assert.assertFalse(m_check.isApplicable(request));
 
     // MAPREDUCE2 installed
-    services.put("MAPREDUCE2", Mockito.mock(Service.class));
+    m_services.put("MAPREDUCE2", Mockito.mock(Service.class));
     Assert.assertTrue(m_check.isApplicable(request));
   }
 
@@ -157,11 +176,15 @@ public class MapReduce2JobHistoryStatePreservingCheckTest {
       }
     });
     Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("MYSTACK-12.2"));
-    RepositoryVersionEntity repositoryVersionEntity = Mockito.mock(RepositoryVersionEntity.class);
     Mockito.when(m_clusters.getCluster("c1")).thenReturn(cluster);
     PrereqCheckRequest request = new PrereqCheckRequest("c1");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.0.0.1");
+
+    // MAPREDUCE2 installed
+    m_services.put("MAPREDUCE2", Mockito.mock(Service.class));
 
-    Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.0.0.1");
     boolean isApplicable = m_check.isApplicable(request);
     Assert.assertTrue(isApplicable);
   }

ambari-server/src/test/java/org/apache/ambari/server/checks/RangerAuditDbCheckTest.java

@@ -22,28 +22,45 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /* Tests for RangerAuditDbCheck */
-
+@RunWith(MockitoJUnitRunner.class)
 public class RangerAuditDbCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private final RangerAuditDbCheck rangerAuditDbCheck = new RangerAuditDbCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     rangerAuditDbCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -53,24 +70,31 @@ public class RangerAuditDbCheckTest {
     };
     Configuration config = Mockito.mock(Configuration.class);
     rangerAuditDbCheck.config = config;
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("RANGER", service);
+    m_services.put("RANGER", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(rangerAuditDbCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    services.remove("RANGER");
-    Assert.assertFalse(rangerAuditDbCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    Assert.assertTrue(rangerAuditDbCheck.isApplicable(request));
+
+    m_services.remove("RANGER");
+    Assert.assertFalse(rangerAuditDbCheck.isApplicable(request));
   }
 
   @Test
@@ -107,5 +131,5 @@ public class RangerAuditDbCheckTest {
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
   }
-  
+
 }

ambari-server/src/test/java/org/apache/ambari/server/checks/RangerPasswordCheckTest.java

@@ -22,7 +22,6 @@ import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.verify;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import java.io.ByteArrayInputStream;
@@ -35,18 +34,24 @@ import java.util.Map;
 
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.controller.internal.URLStreamProvider;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.easymock.EasyMock;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.powermock.api.mockito.PowerMockito;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
@@ -86,8 +91,21 @@ public class RangerPasswordCheckTest {
   private RangerPasswordCheck m_rpc = null;
   private URLStreamProvider m_streamProvider = EasyMock.createMock(URLStreamProvider.class);
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
   public void setup() throws Exception {
+    MockitoAnnotations.initMocks(this);
+
     m_configMap.put("policymgr_external_url", RANGER_URL);
     m_configMap.put("admin_username", "admin");
     m_configMap.put("admin_password", "pass");
@@ -129,43 +147,32 @@ public class RangerPasswordCheckTest {
 
     EasyMock.reset(m_streamProvider);
     PowerMockito.whenNew(URLStreamProvider.class).withAnyArguments().thenReturn(m_streamProvider);
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testApplicable() throws Exception {
 
     final Service service = EasyMock.createMock(Service.class);
-
-    Map<String, Service> services = new HashMap<>();
-    services.put("RANGER", service);
+    m_services.put("RANGER", service);
 
     expect(service.getDesiredStackId()).andReturn(new StackId("HDP-2.3")).anyTimes();
 
     Cluster cluster = m_clusters.getCluster("cluster");
     EasyMock.reset(cluster);
-    expect(cluster.getServices()).andReturn(services).anyTimes();
+    expect(cluster.getServices()).andReturn(m_services).anyTimes();
     expect(cluster.getService("RANGER")).andReturn(service).atLeastOnce();
 
     replay(cluster, service);
 
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-2.3"));
-    assertTrue(m_rpc.isApplicable(request));
-
-    request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-2.2"));
-    assertFalse(m_rpc.isApplicable(request));
-
-    EasyMock.reset(cluster, service);
-    expect(cluster.getServices()).andReturn(services).anyTimes();
-    expect(cluster.getService("RANGER")).andReturn(service).atLeastOnce();
-    expect(service.getDesiredStackId()).andReturn(new StackId("WILDSTACK-2.0")).anyTimes();
-    replay(cluster, service);
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    request = new PrereqCheckRequest("cluster");
-    request.setSourceStackId(new StackId("HDP-2.2"));
     assertTrue(m_rpc.isApplicable(request));
-
   }
 
   @SuppressWarnings("unchecked")

ambari-server/src/test/java/org/apache/ambari/server/checks/RangerSSLConfigCheckTest.java

@@ -22,29 +22,47 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 
 /* Test for RangerSSLConfigCheck */
+@RunWith(MockitoJUnitRunner.class)
 public class RangerSSLConfigCheckTest {
 
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private final RangerSSLConfigCheck rangerSSLConfigCheck = new RangerSSLConfigCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     rangerSSLConfigCheck.clustersProvider = new Provider<Clusters>() {
       @Override
       public Clusters get() {
@@ -53,25 +71,31 @@ public class RangerSSLConfigCheckTest {
     };
     Configuration config = Mockito.mock(Configuration.class);
     rangerSSLConfigCheck.config = config;
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("RANGER", service);
+    m_services.put("RANGER", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(rangerSSLConfigCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    services.remove("RANGER");
-    Assert.assertFalse(rangerSSLConfigCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    Assert.assertTrue(rangerSSLConfigCheck.isApplicable(request));
 
+    m_services.remove("RANGER");
+    Assert.assertFalse(rangerSSLConfigCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/SecondaryNamenodeDeletedCheckTest.java

@@ -25,17 +25,23 @@ import org.apache.ambari.server.api.services.AmbariMetaInfo;
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
 import org.apache.ambari.server.orm.dao.HostComponentStateDAO;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.ServiceComponent;
 import org.apache.ambari.server.state.ServiceComponentHost;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -43,14 +49,26 @@ import com.google.inject.Provider;
  * Unit tests for SecondaryNamenodeDeletedCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class SecondaryNamenodeDeletedCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private final HostComponentStateDAO hostComponentStateDAO = Mockito.mock(HostComponentStateDAO.class);
 
   private final SecondaryNamenodeDeletedCheck secondaryNamenodeDeletedCheck = new SecondaryNamenodeDeletedCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     secondaryNamenodeDeletedCheck.clustersProvider = new Provider<Clusters>() {
       @Override
       public Clusters get() {
@@ -68,31 +86,40 @@ public class SecondaryNamenodeDeletedCheckTest {
     secondaryNamenodeDeletedCheck.hostComponentStateDao = hostComponentStateDAO;
     Configuration config = Mockito.mock(Configuration.class);
     secondaryNamenodeDeletedCheck.config = config;
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("HDFS", service);
+    m_services.put("HDFS", service);
 
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(request));
+
+    request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    PrereqCheckRequest req = new PrereqCheckRequest("cluster");
-    req.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.FAIL);
-    Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(req));
+    request.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.FAIL);
+    Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(request));
 
-    req.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.PASS);
-    Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(req));
+    request.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.PASS);
+    Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(request));
 
-    services.remove("HDFS");
-    Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("HDFS");
+    Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicePresenceCheckTest.java

@@ -124,12 +124,13 @@ public class ServicePresenceCheckTest {
     Mockito.when(cluster.getServices()).thenReturn(services);
 
     Map<String, String> checkProperties = new HashMap<>();
-    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME,"Atlas, OldService");
-    checkProperties.put(ServicePresenceCheck.NEW_SERVICES_PROPERTY_NAME,"Atlas2, NewService");
+    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME, "Atlas, OldService");
+    checkProperties.put(ServicePresenceCheck.NEW_SERVICES_PROPERTY_NAME, "Atlas2, NewService");
 
     PrerequisiteCheckConfig prerequisiteCheckConfig = Mockito.mock(PrerequisiteCheckConfig.class);
-    Mockito.when(prerequisiteCheckConfig.getCheckProperties(
-        m_check.getClass().getName())).thenReturn(checkProperties);
+    Mockito.when(
+        prerequisiteCheckConfig.getCheckProperties(m_check.getClass().getName())).thenReturn(
+            checkProperties);
 
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
     PrereqCheckRequest request = new PrereqCheckRequest("cluster");
@@ -151,7 +152,7 @@ public class ServicePresenceCheckTest {
     Mockito.when(cluster.getServices()).thenReturn(services);
 
     Map<String, String> checkProperties = new HashMap<>();
-    checkProperties.put(ServicePresenceCheck.REMOVED_SERVICES_PROPERTY_NAME,"OldService");
+    checkProperties.put(ServicePresenceCheck.REMOVED_SERVICES_PROPERTY_NAME, "OldService");
 
     PrerequisiteCheckConfig prerequisiteCheckConfig = Mockito.mock(PrerequisiteCheckConfig.class);
     Mockito.when(prerequisiteCheckConfig.getCheckProperties(
@@ -178,9 +179,9 @@ public class ServicePresenceCheckTest {
 
     Map<String, String> checkProperties = new HashMap<>();
     checkProperties.put(ServicePresenceCheck.NO_UPGRADE_SUPPORT_SERVICES_PROPERTY_NAME,"MyServiceOne, MyServiceTwo");
-    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME,"Atlas, OldService");
+    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME, "Atlas, OldService");
     checkProperties.put(ServicePresenceCheck.NEW_SERVICES_PROPERTY_NAME,"Atlas2, NewService");
-    checkProperties.put(ServicePresenceCheck.REMOVED_SERVICES_PROPERTY_NAME,"RemovedService");
+    checkProperties.put(ServicePresenceCheck.REMOVED_SERVICES_PROPERTY_NAME, "RemovedService");
 
     PrerequisiteCheckConfig prerequisiteCheckConfig = Mockito.mock(PrerequisiteCheckConfig.class);
     Mockito.when(prerequisiteCheckConfig.getCheckProperties(
@@ -206,7 +207,7 @@ public class ServicePresenceCheckTest {
 
     Map<String, String> checkProperties = new HashMap<>();
     checkProperties.put(ServicePresenceCheck.NO_UPGRADE_SUPPORT_SERVICES_PROPERTY_NAME,"Atlas, MyService");
-    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME,"OldService");
+    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME, "OldService");
     checkProperties.put(ServicePresenceCheck.NEW_SERVICES_PROPERTY_NAME,"NewService");
 
     PrerequisiteCheckConfig prerequisiteCheckConfig = Mockito.mock(PrerequisiteCheckConfig.class);
@@ -236,7 +237,7 @@ public class ServicePresenceCheckTest {
 
     Map<String, String> checkProperties = new HashMap<>();
     checkProperties.put(ServicePresenceCheck.NO_UPGRADE_SUPPORT_SERVICES_PROPERTY_NAME,"Atlas, HDFS");
-    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME,"Storm, Ranger");
+    checkProperties.put(ServicePresenceCheck.REPLACED_SERVICES_PROPERTY_NAME, "Storm, Ranger");
     checkProperties.put(ServicePresenceCheck.NEW_SERVICES_PROPERTY_NAME,"Storm2, Ranger2");
 
     PrerequisiteCheckConfig prerequisiteCheckConfig = Mockito.mock(PrerequisiteCheckConfig.class);
@@ -250,4 +251,4 @@ public class ServicePresenceCheckTest {
     m_check.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
   }
-}
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesMaintenanceModeCheckTest.java

@@ -18,6 +18,8 @@
 package org.apache.ambari.server.checks;
 
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.apache.ambari.server.api.services.AmbariMetaInfo;
 import org.apache.ambari.server.configuration.Configuration;
@@ -28,12 +30,17 @@ import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
 import org.apache.ambari.server.state.State;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -41,18 +48,33 @@ import com.google.inject.Provider;
  * Unit tests for ServicesMaintenanceModeCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesMaintenanceModeCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
+    m_services.clear();
+
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.2.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2"));
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
@@ -96,12 +118,16 @@ public class ServicesMaintenanceModeCheckTest {
     // We don't bother checking service desired state as it's performed by a separate check
     Mockito.when(service.getDesiredState()).thenReturn(State.UNKNOWN);
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
-    servicesMaintenanceModeCheck.perform(check, new PrereqCheckRequest("cluster"));
+
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    servicesMaintenanceModeCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     Mockito.when(service.getDesiredState()).thenReturn(State.STARTED);
     check = new PrerequisiteCheck(null, null);
-    servicesMaintenanceModeCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesMaintenanceModeCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
   }
 }

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesMapReduceDistributedCacheCheckTest.java

@@ -22,18 +22,24 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -41,13 +47,25 @@ import com.google.inject.Provider;
  * Unit tests for ServicesMapReduceDistributedCacheCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesMapReduceDistributedCacheCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
   private final ServicesMapReduceDistributedCacheCheck servicesMapReduceDistributedCacheCheck = new ServicesMapReduceDistributedCacheCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     servicesMapReduceDistributedCacheCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -57,32 +75,40 @@ public class ServicesMapReduceDistributedCacheCheckTest {
     };
     Configuration config = Mockito.mock(Configuration.class);
     servicesMapReduceDistributedCacheCheck.config = config;
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("YARN", service);
+    m_services.put("YARN", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
 
-    Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(request));
 
-    PrereqCheckRequest req = new PrereqCheckRequest("cluster");
-    req.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.FAIL);
-    Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(req));
+    request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    req.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.PASS);
-    Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(req));
+    request.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.FAIL);
+    Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(request));
 
+    request.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.PASS);
+    Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(request));
 
-    services.remove("YARN");
-    Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("YARN");
+    Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesNamenodeHighAvailabilityCheckTest.java

@@ -23,17 +23,23 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -41,13 +47,25 @@ import com.google.inject.Provider;
  * Unit tests for ServicesNamenodeHighAvailabilityCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesNamenodeHighAvailabilityCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
   private final ServicesNamenodeHighAvailabilityCheck servicesNamenodeHighAvailabilityCheck = new ServicesNamenodeHighAvailabilityCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     servicesNamenodeHighAvailabilityCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -57,24 +75,31 @@ public class ServicesNamenodeHighAvailabilityCheckTest {
     };
     Configuration config = Mockito.mock(Configuration.class);
     servicesNamenodeHighAvailabilityCheck.config = config;
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("HDFS", service);
+    m_services.put("HDFS", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(servicesNamenodeHighAvailabilityCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
+    Assert.assertTrue(servicesNamenodeHighAvailabilityCheck.isApplicable(request));
 
-    services.remove("HDFS");
-    Assert.assertFalse(servicesNamenodeHighAvailabilityCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("HDFS");
+    Assert.assertFalse(servicesNamenodeHighAvailabilityCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesNamenodeTruncateCheckTest.java

@@ -27,21 +27,24 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
-import org.apache.ambari.server.orm.dao.RepositoryVersionDAO;
 import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
-import org.apache.ambari.server.state.RepositoryType;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.easymock.EasyMock;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -49,26 +52,35 @@ import com.google.inject.Provider;
  * Unit tests for ServicesNamenodeTruncateCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesNamenodeTruncateCheckTest {
 
   private Clusters m_clusters = EasyMock.createMock(Clusters.class);
   private ServicesNamenodeTruncateCheck m_check = new ServicesNamenodeTruncateCheck();
   private final Map<String, String> m_configMap = new HashMap<>();
-  private RepositoryVersionDAO m_repositoryVersionDAO = EasyMock.createMock(RepositoryVersionDAO.class);
 
-  final RepositoryVersionEntity repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   @Before
   public void setup() throws Exception {
     Cluster cluster = EasyMock.createMock(Cluster.class);
 
     Config config = EasyMock.createMock(Config.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("HDFS", service);
+    m_services.clear();
+    m_services.put("HDFS", service);
 
-    expect(cluster.getServices()).andReturn(services).anyTimes();
+    expect(cluster.getServices()).andReturn(m_services).anyTimes();
     expect(config.getProperties()).andReturn(m_configMap).anyTimes();
     expect(cluster.getService("HDFS")).andReturn(service);
     expect(cluster.getDesiredConfigByType("hdfs-site")).andReturn(config).anyTimes();
@@ -87,20 +99,12 @@ public class ServicesNamenodeTruncateCheckTest {
       }
     };
 
-    m_check.repositoryVersionDaoProvider = new Provider<RepositoryVersionDAO>() {
-      @Override
-      public RepositoryVersionDAO get() {
-        return m_repositoryVersionDAO;
-      }
-    };
-
-    RepositoryVersionEntity rve = EasyMock.createMock(RepositoryVersionEntity.class);
-    expect(rve.getType()).andReturn(RepositoryType.STANDARD).anyTimes();
-    expect(m_repositoryVersionDAO.findByStackNameAndVersion(EasyMock.anyString(), EasyMock.anyString())).andReturn(rve).anyTimes();
-    replay(m_repositoryVersionDAO, rve);
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("HDP-2.2.0.0");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2.0"));
 
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("HDP-2.2.0.0");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2.0"));
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
 
@@ -109,7 +113,7 @@ public class ServicesNamenodeTruncateCheckTest {
 
     PrereqCheckRequest checkRequest = new PrereqCheckRequest("c1");
     checkRequest.setSourceStackId(new StackId("HDP", "2.2"));
-    checkRequest.setTargetRepositoryVersion(repositoryVersion);
+    checkRequest.setTargetRepositoryVersion(m_repositoryVersion);
 
     Assert.assertTrue(m_check.isApplicable(checkRequest));
   }
@@ -125,9 +129,9 @@ public class ServicesNamenodeTruncateCheckTest {
     m_configMap.put("dfs.allow.truncate", "true");
     request.setSourceStackId(new StackId("HDP-2.2.4.2"));
 
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("2.2.8.4");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2.8.4"));
-    request.setTargetRepositoryVersion(repositoryVersion);
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.2.8.4");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2.8.4"));
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
     check = new PrerequisiteCheck(null, null);
     m_check.perform(check, request);
@@ -142,9 +146,9 @@ public class ServicesNamenodeTruncateCheckTest {
     m_configMap.put("dfs.allow.truncate", "true");
     request.setSourceStackId(new StackId("HDP-2.2.4.2"));
 
-    Mockito.when(repositoryVersion.getVersion()).thenReturn("2.3.8.4");
-    Mockito.when(repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.3.8.4"));
-    request.setTargetRepositoryVersion(repositoryVersion);
+    Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.3.8.4");
+    Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.3.8.4"));
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
     check = new PrerequisiteCheck(null, null);
     m_check.perform(check, request);
@@ -155,4 +159,4 @@ public class ServicesNamenodeTruncateCheckTest {
     m_check.perform(check, request);
     assertEquals(PrereqCheckStatus.PASS, check.getStatus());
   }
-}
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesTezDistributedCacheCheckTest.java

@@ -22,18 +22,24 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.UpgradePack.PrerequisiteCheckConfig;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -41,13 +47,25 @@ import com.google.inject.Provider;
  * Unit tests for ServicesTezDistributedCacheCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesTezDistributedCacheCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
   private final ServicesTezDistributedCacheCheck servicesTezDistributedCacheCheck = new ServicesTezDistributedCacheCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     servicesTezDistributedCacheCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -58,24 +76,31 @@ public class ServicesTezDistributedCacheCheckTest {
     Configuration config = Mockito.mock(Configuration.class);
     servicesTezDistributedCacheCheck.config = config;
 
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("TEZ", service);
+    m_services.put("TEZ", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-    Assert.assertTrue(servicesTezDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    Assert.assertTrue(servicesTezDistributedCacheCheck.isApplicable(request));
 
     PrereqCheckRequest req = new PrereqCheckRequest("cluster");
+    req.setTargetRepositoryVersion(m_repositoryVersion);
+
     req.addResult(CheckDescription.SERVICES_NAMENODE_HA, PrereqCheckStatus.FAIL);
     Assert.assertFalse(servicesTezDistributedCacheCheck.isApplicable(req));
 
@@ -83,8 +108,8 @@ public class ServicesTezDistributedCacheCheckTest {
     Assert.assertTrue(servicesTezDistributedCacheCheck.isApplicable(req));
 
 
-    services.remove("TEZ");
-    Assert.assertFalse(servicesTezDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("TEZ");
+    Assert.assertFalse(servicesTezDistributedCacheCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesUpCheckTest.java

@@ -37,13 +37,17 @@ import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.ServiceComponent;
 import org.apache.ambari.server.state.StackId;
 import org.apache.ambari.server.state.State;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.powermock.api.mockito.PowerMockito;
@@ -63,15 +67,31 @@ public class ServicesUpCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
   private AmbariMetaInfo ambariMetaInfo = Mockito.mock(AmbariMetaInfo.class);
 
-  final RepositoryVersionEntity m_repositoryVersion = Mockito.mock(RepositoryVersionEntity.class);
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
 
   /**
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
+    MockitoAnnotations.initMocks(this);
+
+    m_services.clear();
+
     Mockito.when(m_repositoryVersion.getVersion()).thenReturn("2.2.0.0-1234");
     Mockito.when(m_repositoryVersion.getStackId()).thenReturn(new StackId("HDP", "2.2"));
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
@@ -129,24 +149,28 @@ public class ServicesUpCheckTest {
     final Service tezService = Mockito.mock(Service.class);
     final Service amsService = Mockito.mock(Service.class);
 
-    HashMap<String, Service> clusterServices = new HashMap<>();
-    clusterServices.put("HDFS", hdfsService);
-    clusterServices.put("TEZ", tezService);
-    clusterServices.put("AMBARI_METRICS", amsService);
+    m_services.put("HDFS", hdfsService);
+    m_services.put("TEZ", tezService);
+    m_services.put("AMBARI_METRICS", amsService);
 
     Mockito.when(hdfsService.getName()).thenReturn("HDFS");
     Mockito.when(tezService.getName()).thenReturn("TEZ");
     Mockito.when(amsService.getName()).thenReturn("AMBARI_METRICS");
 
+    StackId stackId = new StackId("HDP", "2.2");
+    Mockito.when(hdfsService.getDesiredStackId()).thenReturn(stackId);
+    Mockito.when(tezService.getDesiredStackId()).thenReturn(stackId);
+    Mockito.when(amsService.getDesiredStackId()).thenReturn(stackId);
+
     Mockito.when(hdfsService.isClientOnlyService()).thenReturn(false);
     Mockito.when(tezService.isClientOnlyService()).thenReturn(true);
     Mockito.when(amsService.isClientOnlyService()).thenReturn(false);
 
-    Mockito.when(hdfsService.getDesiredStackId()).thenReturn(new StackId("HDP", "2.2"));
-    Mockito.when(tezService.getDesiredStackId()).thenReturn(new StackId("HDP", "2.2"));
-    Mockito.when(amsService.getDesiredStackId()).thenReturn(new StackId("HDP", "2.2"));
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
 
-    Mockito.when(cluster.getServices()).thenReturn(clusterServices);
+    Mockito.when(cluster.getService("HDFS")).thenReturn(hdfsService);
+    Mockito.when(cluster.getService("TEZ")).thenReturn(tezService);
+    Mockito.when(cluster.getService("AMBARI_METRICS")).thenReturn(amsService);
 
     Mockito.when(ambariMetaInfo.getComponent(Mockito.anyString(), Mockito.anyString(),
         Mockito.anyString(), Mockito.anyString())).thenAnswer(new Answer<ComponentInfo>() {
@@ -264,8 +288,11 @@ public class ServicesUpCheckTest {
       Mockito.when(hcs.getCurrentState()).thenReturn(State.STARTED);
     }
 
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+
     PrerequisiteCheck check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 2. Change some desired states to STARTED, should still pass
@@ -273,7 +300,7 @@ public class ServicesUpCheckTest {
     Mockito.when(hcsDataNode1.getDesiredState()).thenReturn(State.STARTED);
 
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 3. Ensure that ZKFC and AMS are ignored even if their current state is not STARTED
@@ -282,7 +309,7 @@ public class ServicesUpCheckTest {
     Mockito.when(hcsMetricsMonitor.getCurrentState()).thenReturn(State.INSTALLED);
 
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 4. Change HDFS current states to INSTALLED, should fail.
@@ -290,14 +317,14 @@ public class ServicesUpCheckTest {
     Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
 
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
 
     // Case 5. Change HDFS master to STARTED, but one slave to INSTALLED, should pass (2/3 are up).
     Mockito.when(hcsNameNode.getCurrentState()).thenReturn(State.STARTED);
     Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // Case 6. Change HDFS master to STARTED, but 2 slaves to INSTALLED, should fail (2/3 are down)
@@ -305,7 +332,7 @@ public class ServicesUpCheckTest {
     Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
     Mockito.when(hcsDataNode2.getCurrentState()).thenReturn(State.INSTALLED);
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
     Assert.assertTrue(check.getFailReason().indexOf("50%") > -1);
 
@@ -313,7 +340,7 @@ public class ServicesUpCheckTest {
     Mockito.when(host1.getMaintenanceState(Mockito.anyLong())).thenReturn(MaintenanceState.ON);
     Mockito.when(host3.getMaintenanceState(Mockito.anyLong())).thenReturn(MaintenanceState.ON);
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.PASS, check.getStatus());
 
     // put everything back to normal, then fail NN
@@ -324,13 +351,13 @@ public class ServicesUpCheckTest {
     Mockito.when(host3.getMaintenanceState(Mockito.anyLong())).thenReturn(MaintenanceState.OFF);
 
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
 
     // put NN into MM; should still fail since it's a master
     Mockito.when(host1.getMaintenanceState(Mockito.anyLong())).thenReturn(MaintenanceState.ON);
     check = new PrerequisiteCheck(null, null);
-    servicesUpCheck.perform(check, new PrereqCheckRequest("cluster"));
+    servicesUpCheck.perform(check, request);
     Assert.assertEquals(PrereqCheckStatus.FAIL, check.getStatus());
   }
-}
+}

ambari-server/src/test/java/org/apache/ambari/server/checks/ServicesYarnWorkPreservingCheckTest.java

@@ -23,17 +23,23 @@ import java.util.Map;
 
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Config;
 import org.apache.ambari.server.state.DesiredConfig;
 import org.apache.ambari.server.state.Service;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
@@ -41,13 +47,26 @@ import com.google.inject.Provider;
  * Unit tests for ServicesYarnWorkPreservingCheck
  *
  */
+@RunWith(MockitoJUnitRunner.class)
 public class ServicesYarnWorkPreservingCheckTest {
   private final Clusters clusters = Mockito.mock(Clusters.class);
 
   private final ServicesYarnWorkPreservingCheck servicesYarnWorkPreservingCheck = new ServicesYarnWorkPreservingCheck();
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     servicesYarnWorkPreservingCheck.clustersProvider = new Provider<Clusters>() {
 
       @Override
@@ -57,24 +76,29 @@ public class ServicesYarnWorkPreservingCheckTest {
     };
     Configuration config = Mockito.mock(Configuration.class);
     servicesYarnWorkPreservingCheck.config = config;
+
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
   }
 
   @Test
   public void testIsApplicable() throws Exception {
     final Cluster cluster = Mockito.mock(Cluster.class);
-    final Map<String, Service> services = new HashMap<>();
     final Service service = Mockito.mock(Service.class);
 
-    services.put("YARN", service);
+    m_services.put("YARN", service);
 
-    Mockito.when(cluster.getServices()).thenReturn(services);
+    Mockito.when(cluster.getServices()).thenReturn(m_services);
     Mockito.when(cluster.getClusterId()).thenReturn(1L);
     Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
 
-    Assert.assertTrue(servicesYarnWorkPreservingCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
+    Assert.assertTrue(servicesYarnWorkPreservingCheck.isApplicable(request));
 
-   services.remove("YARN");
-    Assert.assertFalse(servicesYarnWorkPreservingCheck.isApplicable(new PrereqCheckRequest("cluster")));
+    m_services.remove("YARN");
+    Assert.assertFalse(servicesYarnWorkPreservingCheck.isApplicable(request));
   }
 
   @Test

ambari-server/src/test/java/org/apache/ambari/server/checks/StormShutdownWarningTest.java

@@ -21,28 +21,56 @@ import java.util.HashMap;
 import java.util.Map;
 
 import org.apache.ambari.server.controller.PrereqCheckRequest;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.state.Cluster;
 import org.apache.ambari.server.state.Clusters;
 import org.apache.ambari.server.state.Service;
 import org.apache.ambari.server.state.StackId;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockSupport;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
 
 import com.google.inject.Provider;
 
 /**
  * Tests {@link StormShutdownWarning}.
  */
+@RunWith(MockitoJUnitRunner.class)
 public class StormShutdownWarningTest extends EasyMockSupport {
 
   private final String m_clusterName = "c1";
   private final Clusters m_clusters = niceMock(Clusters.class);
 
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
+  @Before
+  public void setup() throws Exception {
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
+  }
+
   /**
    * @throws Exception
    */
@@ -60,18 +88,18 @@ public class StormShutdownWarningTest extends EasyMockSupport {
     final Cluster cluster = niceMock(Cluster.class);
     final Service hive = niceMock(Service.class);
 
-    final Map<String, Service> services = new HashMap<>();
-    services.put("STORM", hive);
+    m_services.put("STORM", hive);
 
     EasyMock.expect(cluster.getClusterId()).andReturn(1L).anyTimes();
 
     EasyMock.expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP", "2.3")).anyTimes();
-    EasyMock.expect(cluster.getServices()).andReturn(services).atLeastOnce();
+    EasyMock.expect(cluster.getServices()).andReturn(m_services).anyTimes();
     EasyMock.expect(m_clusters.getCluster(m_clusterName)).andReturn(cluster).atLeastOnce();
 
     PrereqCheckRequest request = niceMock(PrereqCheckRequest.class);
-    EasyMock.expect(request.getClusterName()).andReturn(m_clusterName);
-    EasyMock.expect(request.getUpgradeType()).andReturn(UpgradeType.ROLLING);
+    EasyMock.expect(request.getClusterName()).andReturn(m_clusterName).anyTimes();
+    EasyMock.expect(request.getUpgradeType()).andReturn(UpgradeType.ROLLING).anyTimes();
+    EasyMock.expect(request.getTargetRepositoryVersion()).andReturn(m_repositoryVersion).anyTimes();
 
     replayAll();
 

ambari-server/src/test/java/org/apache/ambari/server/checks/YarnTimelineServerStatePreservingCheckTest.java

@@ -56,7 +56,7 @@ public class YarnTimelineServerStatePreservingCheckTest {
    *
    */
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     m_check.clustersProvider = new Provider<Clusters>() {
 
       @Override

ambari-server/src/test/java/org/apache/ambari/server/state/CheckHelperTest.java

@@ -19,34 +19,30 @@
 package org.apache.ambari.server.state;
 
 import java.util.ArrayList;
-import java.util.LinkedList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.apache.ambari.server.AmbariException;
-import org.apache.ambari.server.ClusterNotFoundException;
-import org.apache.ambari.server.api.services.AmbariMetaInfo;
 import org.apache.ambari.server.checks.AbstractCheckDescriptor;
 import org.apache.ambari.server.checks.CheckDescription;
-import org.apache.ambari.server.checks.ServicesUpCheck;
 import org.apache.ambari.server.configuration.Configuration;
 import org.apache.ambari.server.controller.PrereqCheckRequest;
-import org.apache.ambari.server.orm.dao.HostVersionDAO;
-import org.apache.ambari.server.orm.dao.RepositoryVersionDAO;
-import org.apache.ambari.server.orm.dao.UpgradeDAO;
-import org.apache.ambari.server.state.stack.OsFamily;
+import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.PrerequisiteCheck;
-import org.apache.ambari.server.state.stack.upgrade.RepositoryVersionHelper;
 import org.easymock.EasyMock;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
+import org.mockito.runners.MockitoJUnitRunner;
 
-import com.google.inject.AbstractModule;
-import com.google.inject.Guice;
-import com.google.inject.Injector;
-import com.google.inject.util.Providers;
+import com.google.inject.Provider;
 
 import junit.framework.Assert;
 
@@ -55,9 +51,41 @@ import junit.framework.Assert;
  * Tests the {@link CheckHelper} class
  * Makes sure that people don't forget to add new checks to registry.
  */
-
+@RunWith(MockitoJUnitRunner.class)
 public class CheckHelperTest {
 
+  private final Clusters clusters = Mockito.mock(Clusters.class);
+
+  private MockCheck m_mockCheck;
+
+  private CheckDescription m_mockCheckDescription = Mockito.mock(CheckDescription.class);
+
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  @Mock
+  private RepositoryVersionEntity m_repositoryVersion;
+
+  @Mock
+  private Object m_mockPerform;
+
+  final Map<String, Service> m_services = new HashMap<>();
+
+  @Before
+  public void setup() throws Exception {
+    m_mockCheck = new MockCheck();
+
+    Mockito.when(m_mockPerform.toString()).thenReturn("Perform!");
+
+    m_services.clear();
+    Mockito.when(m_repositoryVersion.getRepositoryXml()).thenReturn(m_vdfXml);
+    Mockito.when(m_vdfXml.getClusterSummary(Mockito.any(Cluster.class))).thenReturn(m_clusterVersionSummary);
+    Mockito.when(m_clusterVersionSummary.getAvailableServiceNames()).thenReturn(m_services.keySet());
+  }
+
   /**
    * Sunny case when applicable.
    */
@@ -66,17 +94,15 @@ public class CheckHelperTest {
     final CheckHelper helper = new CheckHelper();
     Configuration configuration = EasyMock.createNiceMock(Configuration.class);
     List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
-    AbstractCheckDescriptor descriptor = EasyMock.createNiceMock(AbstractCheckDescriptor.class);
 
     EasyMock.expect(configuration.isUpgradePrecheckBypass()).andReturn(false);
-    descriptor.perform(EasyMock.<PrerequisiteCheck> anyObject(), EasyMock.<PrereqCheckRequest> anyObject());
-    EasyMock.expectLastCall().times(1);
-    EasyMock.expect(descriptor.isApplicable(EasyMock.<PrereqCheckRequest> anyObject())).andReturn(true);
-    EasyMock.replay(descriptor, configuration);
-    updateChecksRegistry.add(descriptor);
-
-    helper.performChecks(new PrereqCheckRequest("cluster"), updateChecksRegistry, configuration);
-    EasyMock.verify(descriptor);
+    EasyMock.replay(configuration);
+    updateChecksRegistry.add(m_mockCheck);
+
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    helper.performChecks(request, updateChecksRegistry, configuration);
+
+    Assert.assertEquals(PrereqCheckStatus.PASS, request.getResult(m_mockCheckDescription));
   }
 
   /**
@@ -84,16 +110,28 @@ public class CheckHelperTest {
    */
   @Test
   public void testPreUpgradeCheckNotApplicable() throws Exception {
+    final Cluster cluster = Mockito.mock(Cluster.class);
+    final Service service = Mockito.mock(Service.class);
+
+    m_services.put("KAFKA", service);
+
+    Mockito.when(cluster.getServices()).thenReturn(new HashMap<String, Service>());
+    Mockito.when(cluster.getClusterId()).thenReturn(1L);
+    Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
+
     final CheckHelper helper = new CheckHelper();
     Configuration configuration = EasyMock.createNiceMock(Configuration.class);
     List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
-    AbstractCheckDescriptor descriptor = EasyMock.createNiceMock(AbstractCheckDescriptor.class);
+
     EasyMock.expect(configuration.isUpgradePrecheckBypass()).andReturn(false);
-    EasyMock.expect(descriptor.isApplicable(EasyMock.<PrereqCheckRequest> anyObject())).andReturn(false);
-    EasyMock.replay(descriptor, configuration);
-    updateChecksRegistry.add(descriptor);
-    helper.performChecks(new PrereqCheckRequest("cluster"), updateChecksRegistry, configuration);
-    EasyMock.verify(descriptor);
+    EasyMock.replay(configuration);
+    updateChecksRegistry.add(m_mockCheck);
+
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    helper.performChecks(request, updateChecksRegistry, configuration);
+
+
+    Assert.assertEquals(null, request.getResult(m_mockCheckDescription));
   }
 
   /**
@@ -102,20 +140,20 @@ public class CheckHelperTest {
   @Test
   public void testPreUpgradeCheckThrowsException() throws Exception {
     final CheckHelper helper = new CheckHelper();
-    List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
-    AbstractCheckDescriptor descriptor = EasyMock.createNiceMock(AbstractCheckDescriptor.class);
     Configuration configuration = EasyMock.createNiceMock(Configuration.class);
+    List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
 
     EasyMock.expect(configuration.isUpgradePrecheckBypass()).andReturn(false);
-    descriptor.perform(EasyMock.<PrerequisiteCheck> anyObject(), EasyMock.<PrereqCheckRequest> anyObject());
-    EasyMock.expectLastCall().andThrow(new AmbariException("error"));
-    EasyMock.expect(descriptor.isApplicable(EasyMock.<PrereqCheckRequest> anyObject())).andReturn(true);
-    EasyMock.expect(descriptor.getDescription()).andReturn(CheckDescription.HOSTS_HEARTBEAT).anyTimes();
-    EasyMock.replay(descriptor, configuration);
-    updateChecksRegistry.add(descriptor);
-    final List<PrerequisiteCheck> upgradeChecks = helper.performChecks(new PrereqCheckRequest("cluster"), updateChecksRegistry, configuration);
-    EasyMock.verify(descriptor);
-    Assert.assertEquals(PrereqCheckStatus.FAIL, upgradeChecks.get(0).getStatus());
+    EasyMock.replay(configuration);
+    updateChecksRegistry.add(m_mockCheck);
+
+    // this will cause an exception
+    Mockito.when(m_mockPerform.toString()).thenThrow(new RuntimeException());
+
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    helper.performChecks(request, updateChecksRegistry, configuration);
+
+    Assert.assertEquals(PrereqCheckStatus.FAIL, request.getResult(m_mockCheckDescription));
   }
 
   /**
@@ -123,98 +161,80 @@ public class CheckHelperTest {
    */
   @Test
   public void testPreUpgradeCheckBypassesFailure() throws Exception {
-    // This mock class extends CheckHelper and overrides the getPrerequisiteChecks method in order to return
-    // a PrerequisiteCheck object whose status is FAIL.
-    final CheckHelperMock helper =  new CheckHelperMock();
+    final CheckHelper helper = new CheckHelper();
     Configuration configuration = EasyMock.createNiceMock(Configuration.class);
     List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
 
-    PrereqCheckRequest checkRequest = EasyMock.createNiceMock(PrereqCheckRequest.class);
     EasyMock.expect(configuration.isUpgradePrecheckBypass()).andReturn(true);
-    EasyMock.expect(checkRequest.getClusterName()).andReturn("c1").anyTimes();
-    EasyMock.replay(checkRequest, configuration);
+    EasyMock.replay(configuration);
+    updateChecksRegistry.add(m_mockCheck);
+
+    // this will cause an exception, triggering the bypass
+    Mockito.when(m_mockPerform.toString()).thenThrow(new RuntimeException());
 
-    final List<PrerequisiteCheck> upgradeChecks = helper.performChecks(checkRequest, updateChecksRegistry, configuration);
-    Assert.assertEquals(1, upgradeChecks.size());
-    Assert.assertEquals(PrereqCheckStatus.BYPASS, upgradeChecks.get(0).getStatus());
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    helper.performChecks(request, updateChecksRegistry, configuration);
+
+    Assert.assertEquals(PrereqCheckStatus.BYPASS, request.getResult(m_mockCheckDescription));
   }
 
   @Test
   public void testPreUpgradeCheckClusterMissing() throws Exception {
-    final Clusters clusters = Mockito.mock(Clusters.class);
+    final Cluster cluster = Mockito.mock(Cluster.class);
+    final Service service = Mockito.mock(Service.class);
+
+    m_services.put("KAFKA", service);
+
+    Mockito.when(cluster.getServices()).thenReturn(new HashMap<String, Service>());
+    Mockito.when(cluster.getClusterId()).thenReturn(1L);
+
+    Mockito.when(clusters.getCluster(Mockito.anyString())).thenReturn(cluster);
+
+    final CheckHelper helper = new CheckHelper();
     Configuration configuration = EasyMock.createNiceMock(Configuration.class);
-    Mockito.when(clusters.getCluster(Mockito.anyString())).thenAnswer(new Answer<Cluster>() {
-      @Override
-      public Cluster answer(InvocationOnMock invocation) throws Throwable {
-        final String clusterName = invocation.getArguments()[0].toString();
-        if (clusterName.equals("existing")) {
-          return Mockito.mock(Cluster.class);
-        } else {
-          throw new ClusterNotFoundException(clusterName);
-        }
-      }
-    });
-
-    final OsFamily osFamily = Mockito.mock(OsFamily.class);
-
-    final Injector injector = Guice.createInjector(new AbstractModule() {
-
-      @Override
-      protected void configure() {
-        bind(Clusters.class).toInstance(clusters);
-        bind(HostVersionDAO.class).toProvider(Providers.<HostVersionDAO>of(null));
-        bind(UpgradeDAO.class).toProvider(Providers.<UpgradeDAO>of(null));
-        bind(RepositoryVersionDAO.class).toProvider(Providers.<RepositoryVersionDAO>of(null));
-        bind(RepositoryVersionHelper.class).toProvider(Providers.<RepositoryVersionHelper>of(null));
-        bind(AmbariMetaInfo.class).toProvider(Providers.<AmbariMetaInfo>of(null));
-        bind(ServicesUpCheck.class).toInstance(new ServicesUpCheck());
-        bind(OsFamily.class).toInstance(osFamily);
-      }
-    });
-
-    final CheckHelper helper = injector.getInstance(CheckHelper.class);
     List<AbstractCheckDescriptor> updateChecksRegistry = new ArrayList<>();
 
     EasyMock.expect(configuration.isUpgradePrecheckBypass()).andReturn(false);
-
     EasyMock.replay(configuration);
+    updateChecksRegistry.add(m_mockCheck);
 
-    // mocked Cluster has no services, so the check should always be PASS
-    updateChecksRegistry.add(injector.getInstance(ServicesUpCheck.class));
-    List<PrerequisiteCheck> upgradeChecks = helper.performChecks(new PrereqCheckRequest("existing"), updateChecksRegistry, configuration);
-    Assert.assertEquals(PrereqCheckStatus.PASS, upgradeChecks.get(0).getStatus());
-    upgradeChecks = helper.performChecks(new PrereqCheckRequest("non-existing"), updateChecksRegistry, configuration);
-    Assert.assertEquals(PrereqCheckStatus.FAIL, upgradeChecks.get(0).getStatus());
-    //non existing cluster is an expected error
-    Assert.assertTrue(!upgradeChecks.get(0).getFailReason().equals("Unexpected server error happened"));
-  }
+    // this will cause an exception, triggering the fail
+    Mockito.when(m_mockPerform.toString()).thenThrow(new RuntimeException());
 
-  class CheckHelperMock extends CheckHelper {
-    @Override
-    public List<DescriptorPreCheck> getApplicablePrerequisiteChecks(PrereqCheckRequest request,
-                                                          List<AbstractCheckDescriptor> checksRegistry) {
+    PrereqCheckRequest request = new PrereqCheckRequest("cluster");
+    request.setTargetRepositoryVersion(m_repositoryVersion);
 
-      List<DescriptorPreCheck> applicablePreChecks = new LinkedList<>();
+    helper.performChecks(request, updateChecksRegistry, configuration);
 
-      try {
-        CheckDescription description = CheckDescription.SERVICES_UP;
-        PrerequisiteCheck check = new PrerequisiteCheck(description, "c1");
-        check.setStatus(PrereqCheckStatus.FAIL);
+    Assert.assertEquals(PrereqCheckStatus.FAIL, request.getResult(m_mockCheckDescription));
+  }
 
-        AbstractCheckDescriptor descriptor = EasyMock.createNiceMock(AbstractCheckDescriptor.class);
-        EasyMock.expect(descriptor.isApplicable(EasyMock.<PrereqCheckRequest>anyObject())).andReturn(true);
-        EasyMock.expect(descriptor.getDescription()).andReturn(description).anyTimes();
+  class MockCheck extends AbstractCheckDescriptor {
 
-        // Allow bypassing failures
-        EasyMock.replay(descriptor);
+    protected MockCheck() {
+      super(m_mockCheckDescription);
 
-        applicablePreChecks.add(new DescriptorPreCheck(descriptor, check));
-      } catch (AmbariException e) {
-        ;
-      }
+      clustersProvider = new Provider<Clusters>() {
 
-      return applicablePreChecks;
+        @Override
+        public Clusters get() {
+          return clusters;
+        }
+      };
     }
-  }
-}
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Set<String> getApplicableServices() {
+      return m_services.keySet();
+    }
+
+    @Override
+    public void perform(PrerequisiteCheck prerequisiteCheck, PrereqCheckRequest request)
+        throws AmbariException {
+      m_mockPerform.toString();
+    }
+  }
+}