def test_wrong_gpfs_filesystem_mount_point(_values):
    LOGGER.info("test_wrong_gpfs_filesystem_mount_point")
    LOGGER.info("gpfs filesystem mount point is wrong")
    test = read_scale_config_file(clusterconfig_value, namespace_value)
    test["scaleHostpath"] = randomStringDigits()
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    operator_object = Scaleoperatorobject(test)
    operator_object.create(kubeconfig_value)

    if operator_object.check(kubeconfig_value) is True:
        LOGGER.error(
            "Operator custom object is deployed successfully not expected")
        assert False
    else:
        get_logs_api_instance = client.CoreV1Api()
        demonset_pod_name = operator_object.get_driver_ds_pod_name()
        try:
            field = "involvedObject.name=" + demonset_pod_name
            api_response = get_logs_api_instance.list_namespaced_event(
                namespace=namespace_value, pretty="True", field_selector=field)
            LOGGER.debug(str(api_response))
            search_result = re.search('MountVolume.SetUp failed for volume',
                                      str(api_response))
            LOGGER.debug(search_result)
            assert search_result is not None
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False

    operator_object.delete(kubeconfig_value)
예제 #2
0
def test_wrong_gui_username(_values):
    LOGGER.info("test_wrong_gui_username : gui username is wrong")
    test = scaleop.read_operator_data(clusterconfig_value, namespace_value)
    test["username"] = randomStringDigits()
    operator_object = scaleop.Scaleoperatorobject(test, kubeconfig_value)
    operator_object.create()
    if operator_object.check() is True:
        LOGGER.error(
            "Operator custom object is deployed successfully not expected")
        assert False
    else:
        daemonset_pod_name = operator_object.get_driver_ds_pod_name()
        get_logs_api_instance = client.CoreV1Api()
        try:
            LOGGER.info(
                f"Checking for failure reason match in {daemonset_pod_name} pod logs"
            )
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=daemonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            x = re.search("401 Unauthorized", get_logs_api_response)
            assert x is not None
            LOGGER.info("'401 Unauthorized' failure reason matched")
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False
    operator_object.delete()
def test_wrong_gui_username(_values):
    LOGGER.info("test_wrong_gui_username")
    LOGGER.info("gui username is wrong")
    test = read_scale_config_file(clusterconfig_value, namespace_value)
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    test["username"] = randomStringDigits()
    operator_object = Scaleoperatorobject(test)
    operator_object.create(kubeconfig_value)
    if operator_object.check(kubeconfig_value) is True:
        LOGGER.error(
            "Operator custom object is deployed successfully not expected")
        assert False
    else:
        demonset_pod_name = operator_object.get_driver_ds_pod_name()
        get_logs_api_instance = client.CoreV1Api()
        try:
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=demonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            x = re.search("401 Unauthorized", get_logs_api_response)
            LOGGER.info(x)
            assert x is not None
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False
    operator_object.delete(kubeconfig_value)
예제 #4
0
def test_random_gpfs_primaryFset_name(_values):
    LOGGER.info(
        "test_random_gpfs_primaryFset_name : gpfs primary Fset name is wrong")
    test = scaleop.read_operator_data(clusterconfig_value, namespace_value)
    random_primaryFset = randomStringDigits()
    test["primaryFset"] = random_primaryFset
    for cluster in test["custom_object_body"]["spec"]["clusters"]:
        if "primary" in cluster.keys():
            cluster["primary"]["primaryFset"] = random_primaryFset

    operator_object = scaleop.Scaleoperatorobject(test, kubeconfig_value)
    operator_object.create()
    if operator_object.check() is True:
        LOGGER.info("Operator custom object is deployed successfully")
    else:
        get_logs_api_instance = client.CoreV1Api()
        try:
            daemonset_pod_name = operator_object.get_driver_ds_pod_name()
            LOGGER.info(
                f"Checking for failure reason match in {daemonset_pod_name} pod logs"
            )
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=daemonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            LOGGER.error(
                "operator custom object should be deployed but it is not deployed hence asserting"
            )
            operator_object.delete()
            if (ff.fileset_exists(test)):
                ff.delete_fileset(test)
            assert False
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            operator_object.delete()
            if (ff.fileset_exists(test)):
                ff.delete_fileset(test)
            assert False
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    operator_object.delete()
예제 #5
0
def test_wrong_guihost(_values):
    LOGGER.info("test_wrong_guihost : gui host is wrong")
    test = scaleop.read_operator_data(clusterconfig_value, namespace_value)
    wrong_guiHost = randomStringDigits()
    test["guiHost"] = wrong_guiHost
    for cluster in test["custom_object_body"]["spec"]["clusters"]:
        if "primary" in cluster.keys():
            cluster["restApi"][0]["guiHost"] = wrong_guiHost

    operator_object = scaleop.Scaleoperatorobject(test, kubeconfig_value)
    operator_object.create()
    if operator_object.check() is True:
        LOGGER.error(
            "Operator custom object is deployed successfully not expected")
        assert False
    else:
        daemonset_pod_name = operator_object.get_driver_ds_pod_name()
        get_logs_api_instance = client.CoreV1Api()
        try:
            LOGGER.info(
                f"Checking for failure reason match in {daemonset_pod_name} pod logs"
            )
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=daemonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            search_result1 = re.search("connection refused",
                                       get_logs_api_response)
            LOGGER.debug(search_result1)
            search_result2 = re.search("no such host", get_logs_api_response)
            LOGGER.debug(search_result2)
            assert (search_result1 is not None or search_result2 is not None)
            LOGGER.info(
                "'connection refused' or 'no such host'  failure reason matched"
            )
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False
    operator_object.delete()
예제 #6
0
def test_wrong_gui_password(_values):
    LOGGER.info("test_wrong_gui_password : gui password is wrong")
    test = scaleop.read_operator_data(clusterconfig_value, namespace_value)
    test["password"] = randomStringDigits()
    operator_object = scaleop.Scaleoperatorobject(test, kubeconfig_value)
    operator_object.create()
    operator_object.check()
    LOGGER.info("Checkig if failure reason matches")
    daemonset_pod_name = operator_object.get_driver_ds_pod_name()
    LOGGER.info(
        f"Checking for failure reason match in {daemonset_pod_name} pod logs")
    get_logs_api_instance = client.CoreV1Api()
    count = 0
    while count < 24:
        try:
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=daemonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            search_result = re.search("401 Unauthorized",
                                      get_logs_api_response)
            if search_result is None:
                time.sleep(5)
                count += 1
            else:
                LOGGER.debug(search_result)
                LOGGER.info("'401 Unauthorized' failure reason matched")
                operator_object.delete()
                return
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False

    operator_object.delete()
    LOGGER.error(str(get_logs_api_response))
    LOGGER.error("Asserting as reason of failure does not match")
    assert search_result is not None
예제 #7
0
def test_wrong_primaryFS(_values):
    LOGGER.info("test_wrong_primaryFS : primaryFS is wrong")
    test = scaleop.read_operator_data(clusterconfig_value, namespace_value)
    wrong_primaryFs = randomStringDigits()

    for cluster in test["custom_object_body"]["spec"]["clusters"]:
        if "primary" in cluster.keys():
            cluster["primary"]["primaryFs"] = wrong_primaryFs
    test["primaryFs"] = wrong_primaryFs
    operator_object = scaleop.Scaleoperatorobject(test, kubeconfig_value)
    operator_object.create()
    if operator_object.check() is True:
        LOGGER.error(
            "Operator custom object is deployed successfully not expected")
        assert False
    else:
        demonset_pod_name = operator_object.get_driver_ds_pod_name()
        get_logs_api_instance = client.CoreV1Api()
        try:
            LOGGER.info(
                f"Checking for failure reason match in {demonset_pod_name} pod logs"
            )
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=demonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            search_result = re.search("Unable to get filesystem",
                                      get_logs_api_response)
            LOGGER.debug(search_result)
            assert search_result is not None
            LOGGER.info("'Unable to get filesystem' failure reason matched")
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False
    operator_object.delete()
def test_random_gpfs_primaryFset_name(_values):
    LOGGER.info("test_ramdom_gpfs_primaryFset_name")
    LOGGER.info("gpfs primary Fset name is wrong")
    test = read_scale_config_file(clusterconfig_value, namespace_value)
    test["primaryFset"] = randomStringDigits()
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    operator_object = Scaleoperatorobject(test)
    operator_object.create(kubeconfig_value)
    if operator_object.check(kubeconfig_value) is True:
        LOGGER.info("Operator custom object is deployed successfully")
    else:
        get_logs_api_instance = client.CoreV1Api()
        try:
            demonset_pod_name = operator_object.get_driver_ds_pod_name()
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=demonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            LOGGER.error(
                "operator custom object should be deployed but it is not deployed hence asserting"
            )
            operator_object.delete(kubeconfig_value)
            if (ff.fileset_exists(test)):
                ff.delete_fileset(test)
            assert False
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            operator_object.delete(kubeconfig_value)
            if (ff.fileset_exists(test)):
                ff.delete_fileset(test)
            assert False
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    operator_object.delete(kubeconfig_value)
def test_wrong_gui_password(_values):
    LOGGER.info("test_wrong_gui_password")
    LOGGER.info("gui password is wrong")
    test = read_scale_config_file(clusterconfig_value, namespace_value)
    if (ff.fileset_exists(test)):
        ff.delete_fileset(test)
    test["password"] = randomStringDigits()
    operator_object = Scaleoperatorobject(test)
    operator_object.create(kubeconfig_value)
    operator_object.check(kubeconfig_value)
    demonset_pod_name = operator_object.get_driver_ds_pod_name()
    get_logs_api_instance = client.CoreV1Api()
    count = 0
    while count < 24:
        try:
            get_logs_api_response = get_logs_api_instance.read_namespaced_pod_log(
                name=demonset_pod_name,
                namespace=namespace_value,
                container="ibm-spectrum-scale-csi")
            LOGGER.debug(str(get_logs_api_response))
            search_result = re.search("Error in authentication request",
                                      get_logs_api_response)
            if search_result is None:
                time.sleep(5)
            else:
                LOGGER.debug(search_result)
                break
            if count > 23:
                operator_object.delete(kubeconfig_value)
                assert search_result is not None
        except ApiException as e:
            LOGGER.error(
                f"Exception when calling CoreV1Api->read_namespaced_pod_log: {e}"
            )
            assert False
    operator_object.delete(kubeconfig_value)