HostValidatorTest.java

package org.ovirt.engine.core.bll.validator;

import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.ovirt.engine.core.bll.validator.ValidationResultMatchers.failsWith;
import static org.ovirt.engine.core.bll.validator.ValidationResultMatchers.isValid;

import java.util.Collections;

import org.apache.commons.lang.StringUtils;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner.Strict;
import org.ovirt.engine.core.bll.hostedengine.HostedEngineHelper;
import org.ovirt.engine.core.common.action.VdsOperationActionParameters.AuthenticationMethod;
import org.ovirt.engine.core.common.businessentities.BusinessEntitiesDefinitions;
import org.ovirt.engine.core.common.businessentities.ExternalComputeResource;
import org.ovirt.engine.core.common.businessentities.ExternalHostGroup;
import org.ovirt.engine.core.common.businessentities.HostedEngineDeployConfiguration;
import org.ovirt.engine.core.common.businessentities.StoragePool;
import org.ovirt.engine.core.common.businessentities.VDS;
import org.ovirt.engine.core.common.businessentities.VDSStatus;
import org.ovirt.engine.core.common.businessentities.VdsStatic;
import org.ovirt.engine.core.common.config.ConfigValues;
import org.ovirt.engine.core.common.errors.EngineMessage;
import org.ovirt.engine.core.compat.Guid;
import org.ovirt.engine.core.dao.StoragePoolDao;
import org.ovirt.engine.core.dao.VdsDao;
import org.ovirt.engine.core.dao.VdsStaticDao;
import org.ovirt.engine.core.utils.MockConfigRule;
import org.ovirt.engine.core.utils.RandomUtils;

@RunWith(Strict.class)
public class HostValidatorTest {

    private static final int HOST_NAME_SIZE = 20;

    @Mock
    private VdsStaticDao hostStaticDao;

    @Mock
    private VdsDao hostDao;

    @Mock
    private StoragePoolDao storagePoolDao;

    @Rule
    public MockConfigRule mockConfigRule = new MockConfigRule();

    @Mock
    private VDS host;

    @Mock
    private HostedEngineHelper hostedEngineHelper;

    @Spy
    @InjectMocks
    private HostValidator validator = new HostValidator(host);

    private void mockHostForActivation(VDSStatus status) {
        when(host.getStatus()).thenReturn(status);
    }

    private void mockHostForUniqueId(String value) {
        mockConfigRule.mockConfigValue(ConfigValues.InstallVds, Boolean.TRUE);
        when(host.getUniqueId()).thenReturn(value);
    }

    @Test
    public void nameIsNull() {
        assertThat(validator.nameNotEmpty(), failsWith(EngineMessage.ACTION_TYPE_FAILED_NAME_MAY_NOT_BE_EMPTY));
    }

    @Test
    public void nameIsEmpty() {
        when(host.getName()).thenReturn("");
        assertThat(validator.nameNotEmpty(), failsWith(EngineMessage.ACTION_TYPE_FAILED_NAME_MAY_NOT_BE_EMPTY));
    }

    @Test
    public void nameNotEmpty() {
        when(host.getName()).thenReturn(RandomUtils.instance().nextString(HOST_NAME_SIZE));
        assertThat(validator.nameNotEmpty(), isValid());
    }

    @Test
    public void nameLengthIsTooLong() {
        mockConfigRule.mockConfigValue(ConfigValues.MaxVdsNameLength, HOST_NAME_SIZE);
        when(host.getName()).thenReturn(RandomUtils.instance().nextString(HOST_NAME_SIZE * 2));
        assertThat(validator.nameLengthIsLegal(), failsWith(EngineMessage.ACTION_TYPE_FAILED_NAME_LENGTH_IS_TOO_LONG));
    }

    @Test
    public void hostNameIsValid() {
        when(host.getHostName()).thenReturn("validName");
        assertThat(validator.hostNameIsValid(), isValid());
    }

    @Test
    public void hostNameIsInvalid() {
        assertThat(validator.hostNameIsValid(), failsWith(EngineMessage.ACTION_TYPE_FAILED_INVALID_VDS_HOSTNAME));
    }

    @Test
    public void nameNotUsed() {
        assertThat(validator.nameNotUsed(), isValid());
    }

    @Test
    public void nameIsUsed() {
        when(hostDao.getByName(any())).thenReturn(mock(VDS.class));

        assertThat(validator.nameNotUsed(), failsWith(EngineMessage.ACTION_TYPE_FAILED_NAME_ALREADY_USED));
    }

    @Test
    public void hostNameNotUsed() {
        assertThat(validator.hostNameNotUsed(), isValid());
    }

    @Test
    public void hostNameIsUsed() {
        when(hostDao.getAllForHostname(any())).thenReturn(Collections.singletonList(mock(VDS.class)));

        assertThat(validator.hostNameNotUsed(), failsWith(EngineMessage.ACTION_TYPE_FAILED_VDS_WITH_SAME_HOST_EXIST));
    }

    @Test
    public void portIsValid() {
        when(host.getSshPort()).thenReturn(BusinessEntitiesDefinitions.NETWORK_MIN_LEGAL_PORT);
        assertThat(validator.portIsValid(), isValid());
    }

    @Test
    public void portIsInvalid() {
        assertThat(validator.portIsValid(), failsWith(EngineMessage.ACTION_TYPE_FAILED_VDS_WITH_INVALID_SSH_PORT));
    }

    @Test
    public void sshUserNameNotEmpty() {
        when(host.getSshUsername()).thenReturn(RandomUtils.instance().nextString(HOST_NAME_SIZE));
        assertThat(validator.sshUserNameNotEmpty(), isValid());
    }

    @Test
    public void sshUserNameIsEmpty() {
        assertThat(validator.sshUserNameNotEmpty(),
                failsWith(EngineMessage.ACTION_TYPE_FAILED_VDS_WITH_INVALID_SSH_USERNAME));
    }

    @Test
    public void hostAttachedToLocalStorageWithoutDataCenter() {
        assertThat(validator.validateSingleHostAttachedToLocalStorage(), isValid());
    }

    @Test
    public void validateSingleHostAttachedToLocalStorage() {
        assertThat(validator.validateSingleHostAttachedToLocalStorage(), isValid());
    }

    @Test
    public void validateSingleHostAttachedToFewStorages() {
        StoragePool dataCenter = mock(StoragePool.class);
        when(dataCenter.isLocal()).thenReturn(true);
        when(storagePoolDao.getForCluster(any())).thenReturn(dataCenter);
        when(hostStaticDao.getAllForCluster(any()))
                .thenReturn(Collections.singletonList(mock(VdsStatic.class)));

        assertThat(validator.validateSingleHostAttachedToLocalStorage(),
                failsWith(EngineMessage.VDS_CANNOT_ADD_MORE_THEN_ONE_HOST_TO_LOCAL_STORAGE));
    }

    @Test
    public void securityKeysExists() {
        doReturn(true).when(validator).haveSecurityKey();

        assertThat(validator.securityKeysExists(), isValid());
    }

    @Test
    public void securityKeysDoesNotExist() {
        doReturn(false).when(validator).haveSecurityKey();

        assertThat(validator.securityKeysExists(),
                failsWith(EngineMessage.VDS_TRY_CREATE_SECURE_CERTIFICATE_NOT_FOUND));
    }

    @Test
    public void passwordNotEmpty() {
        assertThat(validator.passwordNotEmpty(false,
                AuthenticationMethod.Password,
                RandomUtils.instance().nextString(10)),
                isValid());
    }

    @Test
    public void passwordIsEmpty() {
        assertThat(validator.passwordNotEmpty(false, AuthenticationMethod.Password, null),
                failsWith(EngineMessage.VDS_CANNOT_INSTALL_EMPTY_PASSWORD));
    }

    @Test
    public void passwordIsEmptyWhenUsingPublicKey() {
        assertThat(validator.passwordNotEmpty(false, AuthenticationMethod.PublicKey, null), isValid());
    }

    @Test
    public void passwordIsEmptyForOvirtNode() {
        assertThat(validator.passwordNotEmpty(true, RandomUtils.instance().nextEnum(AuthenticationMethod.class), null),
                isValid());
    }

    @Test
    public void provisioningComputeResourceEmpty() {
        assertThat(validator.provisioningComputeResourceValid(true, null),
                failsWith(EngineMessage.VDS_PROVIDER_PROVISION_MISSING_COMPUTERESOURCE));
    }

    @Test
    public void provisioningHostGroupEmpty() {
        assertThat(validator.provisioningHostGroupValid(true, null),
                failsWith(EngineMessage.VDS_PROVIDER_PROVISION_MISSING_HOSTGROUP));
    }

    @Test
    public void provisioningNotProvided() {
        assertThat(validator.provisioningComputeResourceValid(false, null), isValid());
        assertThat(validator.provisioningHostGroupValid(false, null), isValid());
    }

    @Test
    public void provisioningProvided() {
        assertThat(validator.provisioningComputeResourceValid(false, new ExternalComputeResource()), isValid());
        assertThat(validator.provisioningHostGroupValid(false, new ExternalHostGroup()), isValid());
        assertThat(validator.provisioningComputeResourceValid(true, new ExternalComputeResource()), isValid());
        assertThat(validator.provisioningHostGroupValid(true, new ExternalHostGroup()), isValid());
    }

    @Test
    public void testValidateStatusUpForActivation() {
        mockHostForActivation(VDSStatus.Up);
        assertThat(validator.validateStatusForActivation(), failsWith( EngineMessage.VDS_ALREADY_UP));
    }

    @Test
    public void testValidateStatusNonResponsiveForActivation() {
        mockHostForActivation(VDSStatus.NonResponsive);
        assertThat(validator.validateStatusForActivation(), failsWith( EngineMessage.VDS_NON_RESPONSIVE));
    }

    @Test
    public void testValidateNoUniqueId() {
        mockHostForUniqueId(StringUtils.EMPTY);
        assertThat(validator.validateUniqueId(), failsWith( EngineMessage.VDS_NO_UUID));
    }

    @Test
    public void testValidateUniqueId() {
        mockHostForUniqueId(Guid.newGuid().toString());
        assertThat(validator.validateUniqueId(), isValid());
    }

    @Test
    public void testIsNotUp() {
        mockHostForActivation(VDSStatus.Down);
        assertThat(validator.isUp(), failsWith(EngineMessage.ACTION_TYPE_FAILED_VDS_STATUS_ILLEGAL, "$hostStatus Up"));
    }

    @Test
    public void testIsUp() {
        mockHostForActivation(VDSStatus.Up);
        assertTrue(validator.isUp().isValid());
    }

    @Test
    public void testValidStatusForEnrollCertificate() {
        mockHostForActivation(VDSStatus.Maintenance);
        assertThat(validator.validateStatusForEnrollCertificate(), isValid());
    }

    @Test
    public void testInvalidStatusForEnrollCertificate() {
        mockHostForActivation(VDSStatus.Up);
        assertThat(validator.validateStatusForEnrollCertificate(),
                failsWith(EngineMessage.CANNOT_ENROLL_CERTIFICATE_HOST_STATUS_ILLEGAL));
    }

    @Test
    public void supportsHostedEngineDeploy() {
        when(hostedEngineHelper.isVmManaged()).thenReturn(true);
        assertThat(validator.supportsDeployingHostedEngine(new HostedEngineDeployConfiguration(HostedEngineDeployConfiguration.Action.DEPLOY)),
                isValid());
    }

    @Test
    public void supportsHostedEngineDeployInVersion36() {
        when(hostedEngineHelper.isVmManaged()).thenReturn(true);
        assertThat(validator.supportsDeployingHostedEngine(new HostedEngineDeployConfiguration(HostedEngineDeployConfiguration.Action.DEPLOY)),
                isValid());
    }

    @Test
    public void unsupportedHostedEngineDeployWhenNoHostedEngine() {
        when(hostedEngineHelper.isVmManaged()).thenReturn(false);
        assertThat(validator.supportsDeployingHostedEngine(new HostedEngineDeployConfiguration(HostedEngineDeployConfiguration.Action.DEPLOY)),
                failsWith(EngineMessage.ACTION_TYPE_FAILED_UNMANAGED_HOSTED_ENGINE));
    }

    @Test
    public void allow36HostWithoutDeployingHostedEngine() {
        HostedEngineDeployConfiguration heConfig =
                new HostedEngineDeployConfiguration(HostedEngineDeployConfiguration.Action.NONE);
        assertThat(validator.supportsDeployingHostedEngine(heConfig), isValid());
    }
}