# Copyright 2016 Tesora, Inc.
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.
#

from proboscis import test

from trove.tests.scenario import groups
from trove.tests.scenario.groups.test_group import TestGroup
from trove.tests.scenario.runners import test_runners


GROUP = "scenario.module_group"


class ModuleRunnerFactory(test_runners.RunnerFactory):

    _runner_ns = 'module_runners'
    _runner_cls = 'ModuleRunner'


@test(groups=[GROUP, groups.MODULE_CREATE])
class ModuleCreateGroup(TestGroup):
    """Test Module Create functionality."""

    def __init__(self):
        super(ModuleCreateGroup, self).__init__(
            ModuleRunnerFactory.instance())

    @test
    def module_delete_existing(self):
        """Delete all previous test modules."""
        self.test_runner.run_module_delete_existing()

    @test
    def module_create_bad_type(self):
        """Ensure create module with invalid type fails."""
        self.test_runner.run_module_create_bad_type()

    @test
    def module_create_non_admin_auto(self):
        """Ensure create auto_apply module for non-admin fails."""
        self.test_runner.run_module_create_non_admin_auto()

    @test
    def module_create_non_admin_all_tenant(self):
        """Ensure create all tenant module for non-admin fails."""
        self.test_runner.run_module_create_non_admin_all_tenant()

    @test
    def module_create_non_admin_hidden(self):
        """Ensure create hidden module for non-admin fails."""
        self.test_runner.run_module_create_non_admin_hidden()

    @test
    def module_create_non_admin_priority(self):
        """Ensure create priority module for non-admin fails."""
        self.test_runner.run_module_create_non_admin_priority()

    @test
    def module_create_non_admin_no_full_access(self):
        """Ensure create no full access module for non-admin fails."""
        self.test_runner.run_module_create_non_admin_no_full_access()

    @test
    def module_create_full_access_with_admin_opt(self):
        """Ensure create full access module with admin opts fails."""
        self.test_runner.run_module_create_full_access_with_admin_opt()

    @test
    def module_create_bad_datastore(self):
        """Ensure create module with invalid datastore fails."""
        self.test_runner.run_module_create_bad_datastore()

    @test
    def module_create_bad_datastore_version(self):
        """Ensure create module with invalid datastore_version fails."""
        self.test_runner.run_module_create_bad_datastore_version()

    @test
    def module_create_missing_datastore(self):
        """Ensure create module with missing datastore fails."""
        self.test_runner.run_module_create_missing_datastore()

    @test(runs_after=[module_delete_existing])
    def module_create(self):
        """Check that create module works."""
        self.test_runner.run_module_create()

    @test(runs_after=[module_create])
    def module_create_for_update(self):
        """Check that create module for update works."""
        self.test_runner.run_module_create_for_update()

    @test(depends_on=[module_create])
    def module_create_dupe(self):
        """Ensure create with duplicate info fails."""
        self.test_runner.run_module_create_dupe()

    @test(depends_on=[module_create_for_update])
    def module_update_missing_datastore(self):
        """Ensure update module with missing datastore fails."""
        self.test_runner.run_module_update_missing_datastore()

    @test(runs_after=[module_create_for_update])
    def module_create_bin(self):
        """Check that create module with binary contents works."""
        self.test_runner.run_module_create_bin()

    @test(runs_after=[module_create_bin])
    def module_create_bin2(self):
        """Check that create module with other binary contents works."""
        self.test_runner.run_module_create_bin2()

    @test(depends_on=[module_create])
    def module_show(self):
        """Check that show module works."""
        self.test_runner.run_module_show()

    @test(depends_on=[module_create])
    def module_show_unauth_user(self):
        """Ensure that show module for unauth user fails."""
        self.test_runner.run_module_show_unauth_user()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2])
    def module_list(self):
        """Check that list modules works."""
        self.test_runner.run_module_list()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2])
    def module_list_unauth_user(self):
        """Ensure that list module for unauth user fails."""
        self.test_runner.run_module_list_unauth_user()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_list])
    def module_create_admin_all(self):
        """Check that create module works with all admin options."""
        self.test_runner.run_module_create_admin_all()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_admin_all])
    def module_create_admin_hidden(self):
        """Check that create module works with hidden option."""
        self.test_runner.run_module_create_admin_hidden()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_admin_hidden])
    def module_create_admin_auto(self):
        """Check that create module works with auto option."""
        self.test_runner.run_module_create_admin_auto()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_admin_auto])
    def module_create_admin_live_update(self):
        """Check that create module works with live-update option."""
        self.test_runner.run_module_create_admin_live_update()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_admin_live_update])
    def module_create_admin_priority_apply(self):
        """Check that create module works with priority-apply option."""
        self.test_runner.run_module_create_admin_priority_apply()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_admin_priority_apply])
    def module_create_datastore(self):
        """Check that create module with datastore works."""
        self.test_runner.run_module_create_datastore()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_datastore])
    def module_create_different_datastore(self):
        """Check that create module with different datastore works."""
        self.test_runner.run_module_create_different_datastore()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_different_datastore])
    def module_create_ds_version(self):
        """Check that create module with ds version works."""
        self.test_runner.run_module_create_ds_version()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_ds_version])
    def module_create_all_tenant(self):
        """Check that create 'all' tenants with datastore module works."""
        self.test_runner.run_module_create_all_tenant()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_all_tenant, module_list_unauth_user])
    def module_create_different_tenant(self):
        """Check that create with same name on different tenant works."""
        self.test_runner.run_module_create_different_tenant()

    @test(depends_on=[module_create, module_create_bin, module_create_bin2],
          runs_after=[module_create_different_tenant])
    def module_create_full_access(self):
        """Check that create by admin with full access works."""
        self.test_runner.run_module_create_full_access()

    @test(depends_on=[module_create_all_tenant],
          runs_after=[module_create_full_access])
    def module_full_access_toggle(self):
        """Check that toggling full access works."""
        self.test_runner.run_module_full_access_toggle()

    @test(depends_on=[module_create_all_tenant],
          runs_after=[module_full_access_toggle])
    def module_list_again(self):
        """Check that list modules skips invisible modules."""
        self.test_runner.run_module_list_again()

    @test(depends_on=[module_create_ds_version],
          runs_after=[module_list_again])
    def module_list_ds(self):
        """Check that list modules by datastore works."""
        self.test_runner.run_module_list_ds()

    @test(depends_on=[module_create_ds_version],
          runs_after=[module_list_ds])
    def module_list_ds_all(self):
        """Check that list modules by all datastores works."""
        self.test_runner.run_module_list_ds_all()

    @test(depends_on=[module_create_admin_hidden])
    def module_show_invisible(self):
        """Ensure that show invisible module for non-admin fails."""
        self.test_runner.run_module_show_invisible()

    @test(depends_on=[module_create_all_tenant],
          runs_after=[module_create_different_tenant])
    def module_list_admin(self):
        """Check that list modules for admin works."""
        self.test_runner.run_module_list_admin()

    @test(depends_on=[module_create],
          runs_after=[module_show])
    def module_update(self):
        """Check that update module works."""
        self.test_runner.run_module_update()

    @test(depends_on=[module_update])
    def module_update_same_contents(self):
        """Check that update module with same contents works."""
        self.test_runner.run_module_update_same_contents()

    @test(depends_on=[module_update],
          runs_after=[module_update_same_contents])
    def module_update_auto_toggle(self):
        """Check that update module works for auto apply toggle."""
        self.test_runner.run_module_update_auto_toggle()

    @test(depends_on=[module_update],
          runs_after=[module_update_auto_toggle])
    def module_update_all_tenant_toggle(self):
        """Check that update module works for all tenant toggle."""
        self.test_runner.run_module_update_all_tenant_toggle()

    @test(depends_on=[module_update],
          runs_after=[module_update_all_tenant_toggle])
    def module_update_invisible_toggle(self):
        """Check that update module works for invisible toggle."""
        self.test_runner.run_module_update_invisible_toggle()

    @test(depends_on=[module_update],
          runs_after=[module_update_invisible_toggle])
    def module_update_priority_toggle(self):
        """Check that update module works for priority toggle."""
        self.test_runner.run_module_update_priority_toggle()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_unauth(self):
        """Ensure update module for unauth user fails."""
        self.test_runner.run_module_update_unauth()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_auto(self):
        """Ensure update module to auto_apply for non-admin fails."""
        self.test_runner.run_module_update_non_admin_auto()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_auto_off(self):
        """Ensure update module to auto_apply off for non-admin fails."""
        self.test_runner.run_module_update_non_admin_auto_off()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_auto_any(self):
        """Ensure any update module to auto_apply for non-admin fails."""
        self.test_runner.run_module_update_non_admin_auto_any()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_all_tenant(self):
        """Ensure update module to all tenant for non-admin fails."""
        self.test_runner.run_module_update_non_admin_all_tenant()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_all_tenant_off(self):
        """Ensure update module to all tenant off for non-admin fails."""
        self.test_runner.run_module_update_non_admin_all_tenant_off()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_all_tenant_any(self):
        """Ensure any update module to all tenant for non-admin fails."""
        self.test_runner.run_module_update_non_admin_all_tenant_any()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_invisible(self):
        """Ensure update module to invisible for non-admin fails."""
        self.test_runner.run_module_update_non_admin_invisible()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_invisible_off(self):
        """Ensure update module to invisible off for non-admin fails."""
        self.test_runner.run_module_update_non_admin_invisible_off()

    @test(depends_on=[module_update],
          runs_after=[module_update_priority_toggle])
    def module_update_non_admin_invisible_any(self):
        """Ensure any update module to invisible for non-admin fails."""
        self.test_runner.run_module_update_non_admin_invisible_any()


@test(depends_on_groups=[groups.INST_CREATE_WAIT, groups.MODULE_CREATE],
      runs_after_groups=[groups.INST_ERROR_DELETE, groups.INST_FORCE_DELETE],
      groups=[GROUP, groups.MODULE_INST, groups.MODULE_INST_CREATE])
class ModuleInstCreateGroup(TestGroup):
    """Test Module Instance Create functionality."""

    def __init__(self):
        super(ModuleInstCreateGroup, self).__init__(
            ModuleRunnerFactory.instance())

    @test
    def module_list_instance_empty(self):
        """Check that the instance has no modules associated."""
        self.test_runner.run_module_list_instance_empty()

    @test(runs_after=[module_list_instance_empty])
    def module_instances_empty(self):
        """Check that the module hasn't been applied to any instances."""
        self.test_runner.run_module_instances_empty()

    @test(runs_after=[module_instances_empty])
    def module_instance_count_empty(self):
        """Check that no instance count exists."""
        self.test_runner.run_module_instance_count_empty()

    @test(runs_after=[module_instance_count_empty])
    def module_query_empty(self):
        """Check that the instance has no modules applied."""
        self.test_runner.run_module_query_empty()

    @test(runs_after=[module_query_empty])
    def module_apply(self):
        """Check that module-apply works."""
        self.test_runner.run_module_apply()

    @test(runs_after=[module_apply])
    def module_apply_wrong_module(self):
        """Ensure that module-apply for wrong module fails."""
        self.test_runner.run_module_apply_wrong_module()

    @test(depends_on=[module_apply_wrong_module])
    def module_update_not_live(self):
        """Ensure updating a non live_update module fails."""
        self.test_runner.run_module_update_not_live()

    @test(depends_on=[module_apply],
          runs_after=[module_update_not_live])
    def module_list_instance_after_apply(self):
        """Check that the instance has the modules associated."""
        self.test_runner.run_module_list_instance_after_apply()

    @test(runs_after=[module_list_instance_after_apply])
    def module_apply_live_update(self):
        """Check that module-apply works for live_update."""
        self.test_runner.run_module_apply_live_update()

    @test(depends_on=[module_apply_live_update])
    def module_list_instance_after_apply_live(self):
        """Check that the instance has the right modules."""
        self.test_runner.run_module_list_instance_after_apply_live()

    @test(runs_after=[module_list_instance_after_apply_live])
    def module_instances_after_apply(self):
        """Check that the instance shows up in the list."""
        self.test_runner.run_module_instances_after_apply()

    @test(runs_after=[module_instances_after_apply])
    def module_instance_count_after_apply(self):
        """Check that the instance count is right after apply."""
        self.test_runner.run_module_instance_count_after_apply()

    @test(runs_after=[module_instance_count_after_apply])
    def module_query_after_apply(self):
        """Check that module-query works."""
        self.test_runner.run_module_query_after_apply()

    @test(runs_after=[module_query_after_apply])
    def module_update_live_update(self):
        """Check that update module works on 'live' applied module."""
        self.test_runner.run_module_update_live_update()

    @test(runs_after=[module_update_live_update])
    def module_apply_another(self):
        """Check that module-apply works for another module."""
        self.test_runner.run_module_apply_another()

    @test(depends_on=[module_apply_another])
    def module_list_instance_after_apply_another(self):
        """Check that the instance has the right modules again."""
        self.test_runner.run_module_list_instance_after_apply_another()

    @test(runs_after=[module_list_instance_after_apply_another])
    def module_instances_after_apply_another(self):
        """Check that the instance shows up in the list still."""
        self.test_runner.run_module_instances_after_apply_another()

    @test(runs_after=[module_instances_after_apply_another])
    def module_instance_count_after_apply_another(self):
        """Check that the instance count is right after another apply."""
        self.test_runner.run_module_instance_count_after_apply_another()

    @test(depends_on=[module_apply_another],
          runs_after=[module_instance_count_after_apply_another])
    def module_query_after_apply_another(self):
        """Check that module-query works after another apply."""
        self.test_runner.run_module_query_after_apply_another()

    @test(depends_on=[module_apply],
          runs_after=[module_query_after_apply_another])
    def create_inst_with_mods(self):
        """Check that creating an instance with modules works."""
        self.test_runner.run_create_inst_with_mods()

    @test(runs_after=[create_inst_with_mods])
    def create_inst_with_wrong_module(self):
        """Ensure that creating an inst with wrong ds mod fails."""
        self.test_runner.run_create_inst_with_wrong_module()

    @test(depends_on=[module_apply],
          runs_after=[create_inst_with_wrong_module])
    def module_delete_applied(self):
        """Ensure that deleting an applied module fails."""
        self.test_runner.run_module_delete_applied()

    @test(depends_on=[module_apply],
          runs_after=[module_delete_applied])
    def module_remove(self):
        """Check that module-remove works."""
        self.test_runner.run_module_remove()

    @test(depends_on=[module_remove])
    def module_query_after_remove(self):
        """Check that the instance has modules applied after remove."""
        self.test_runner.run_module_query_after_remove()

    @test(depends_on=[module_remove],
          runs_after=[module_query_after_remove])
    def module_update_after_remove(self):
        """Check that update module after remove works."""
        self.test_runner.run_module_update_after_remove()

    @test(depends_on=[module_remove],
          runs_after=[module_update_after_remove])
    def module_apply_another_again(self):
        """Check that module-apply another works a second time."""
        self.test_runner.run_module_apply_another()

    @test(depends_on=[module_apply],
          runs_after=[module_apply_another_again])
    def module_query_after_apply_another2(self):
        """Check that module-query works still."""
        self.test_runner.run_module_query_after_apply_another()

    @test(depends_on=[module_apply_another_again],
          runs_after=[module_query_after_apply_another2])
    def module_remove_again(self):
        """Check that module-remove works again."""
        self.test_runner.run_module_remove()

    @test(depends_on=[module_remove_again])
    def module_query_empty_after_again(self):
        """Check that the inst has right mod applied after 2nd remove."""
        self.test_runner.run_module_query_after_remove()

    @test(depends_on=[module_remove_again],
          runs_after=[module_query_empty_after_again])
    def module_update_after_remove_again(self):
        """Check that update module after remove again works."""
        self.test_runner.run_module_update_after_remove_again()


@test(depends_on_groups=[groups.MODULE_INST_CREATE],
      groups=[GROUP, groups.MODULE_INST, groups.MODULE_INST_CREATE_WAIT],
      runs_after_groups=[groups.INST_ACTIONS, groups.INST_UPGRADE])
class ModuleInstCreateWaitGroup(TestGroup):
    """Test that Module Instance Create Completes."""

    def __init__(self):
        super(ModuleInstCreateWaitGroup, self).__init__(
            ModuleRunnerFactory.instance())

    @test
    def wait_for_inst_with_mods(self):
        """Wait for create instance with modules to finish."""
        self.test_runner.run_wait_for_inst_with_mods()

    @test(depends_on=[wait_for_inst_with_mods])
    def module_query_after_inst_create(self):
        """Check that module-query works on new instance."""
        self.test_runner.run_module_query_after_inst_create()

    @test(depends_on=[wait_for_inst_with_mods],
          runs_after=[module_query_after_inst_create])
    def module_retrieve_after_inst_create(self):
        """Check that module-retrieve works on new instance."""
        self.test_runner.run_module_retrieve_after_inst_create()

    @test(depends_on=[wait_for_inst_with_mods],
          runs_after=[module_retrieve_after_inst_create])
    def module_query_after_inst_create_admin(self):
        """Check that module-query works for admin."""
        self.test_runner.run_module_query_after_inst_create_admin()

    @test(depends_on=[wait_for_inst_with_mods],
          runs_after=[module_query_after_inst_create_admin])
    def module_retrieve_after_inst_create_admin(self):
        """Check that module-retrieve works for admin."""
        self.test_runner.run_module_retrieve_after_inst_create_admin()

    @test(depends_on=[wait_for_inst_with_mods],
          runs_after=[module_retrieve_after_inst_create_admin])
    def module_delete_auto_applied(self):
        """Ensure that module-delete on auto-applied module fails."""
        self.test_runner.run_module_delete_auto_applied()

    @test(runs_after=[module_delete_auto_applied])
    def module_list_instance_after_mod_inst(self):
        """Check that the new instance has the right modules."""
        self.test_runner.run_module_list_instance_after_mod_inst()

    @test(runs_after=[module_list_instance_after_mod_inst])
    def module_instances_after_mod_inst(self):
        """Check that the new instance shows up in the list."""
        self.test_runner.run_module_instances_after_mod_inst()

    @test(runs_after=[module_instances_after_mod_inst])
    def module_instance_count_after_mod_inst(self):
        """Check that the new instance count is right."""
        self.test_runner.run_module_instance_count_after_mod_inst()

    @test(runs_after=[module_instance_count_after_mod_inst])
    def module_reapply_with_md5(self):
        """Check that module reapply with md5 works."""
        self.test_runner.run_module_reapply_with_md5()

    @test(runs_after=[module_reapply_with_md5])
    def module_reapply_with_md5_verify(self):
        """Verify the dates after md5 reapply (no-op)."""
        self.test_runner.run_module_reapply_with_md5_verify()

    @test(runs_after=[module_reapply_with_md5_verify])
    def module_list_instance_after_reapply_md5(self):
        """Check that the instance's modules haven't changed."""
        self.test_runner.run_module_list_instance_after_reapply_md5()

    @test(runs_after=[module_list_instance_after_reapply_md5])
    def module_instances_after_reapply_md5(self):
        """Check that the new instance still shows up in the list."""
        self.test_runner.run_module_instances_after_reapply_md5()

    @test(runs_after=[module_instances_after_reapply_md5])
    def module_instance_count_after_reapply_md5(self):
        """Check that the instance count hasn't changed."""
        self.test_runner.run_module_instance_count_after_reapply_md5()

    @test(runs_after=[module_instance_count_after_reapply_md5])
    def module_reapply_all(self):
        """Check that module reapply works."""
        self.test_runner.run_module_reapply_all()

    @test(runs_after=[module_reapply_all])
    def module_reapply_all_wait(self):
        """Wait for module reapply to complete."""
        self.test_runner.run_module_reapply_all_wait()

    @test(runs_after=[module_reapply_all_wait])
    def module_instance_count_after_reapply(self):
        """Check that the reapply instance count is right."""
        self.test_runner.run_module_instance_count_after_reapply()

    @test(runs_after=[module_instance_count_after_reapply])
    def module_reapply_with_force(self):
        """Check that module reapply with force works."""
        self.test_runner.run_module_reapply_with_force()

    @test(runs_after=[module_reapply_with_force])
    def module_reapply_with_force_wait(self):
        """Wait for module reapply with force to complete."""
        self.test_runner.run_module_reapply_with_force_wait()

    @test(runs_after=[module_reapply_with_force_wait])
    def module_list_instance_after_reapply_force(self):
        """Check that the new instance still has the right modules."""
        self.test_runner.run_module_list_instance_after_reapply()

    @test(runs_after=[module_list_instance_after_reapply_force])
    def module_instances_after_reapply_force(self):
        """Check that the new instance still shows up in the list."""
        self.test_runner.run_module_instances_after_reapply()

    @test(runs_after=[module_instances_after_reapply_force])
    def module_instance_count_after_reapply_force(self):
        """Check that the instance count is right after reapply force."""
        self.test_runner.run_module_instance_count_after_reapply()


@test(depends_on_groups=[groups.MODULE_INST_CREATE_WAIT],
      groups=[GROUP, groups.MODULE_INST, groups.MODULE_INST_DELETE])
class ModuleInstDeleteGroup(TestGroup):
    """Test Module Instance Delete functionality."""

    def __init__(self):
        super(ModuleInstDeleteGroup, self).__init__(
            ModuleRunnerFactory.instance())

    @test
    def delete_inst_with_mods(self):
        """Check that instance with module can be deleted."""
        self.test_runner.run_delete_inst_with_mods()

    @test(runs_after=[delete_inst_with_mods])
    def remove_mods_from_main_inst(self):
        """Check that modules can be removed from the main instance."""
        self.test_runner.run_remove_mods_from_main_inst()


@test(depends_on_groups=[groups.MODULE_INST_DELETE],
      groups=[GROUP, groups.MODULE_INST, groups.MODULE_INST_DELETE_WAIT],
      runs_after_groups=[groups.INST_DELETE])
class ModuleInstDeleteWaitGroup(TestGroup):
    """Test that Module Instance Delete Completes."""

    def __init__(self):
        super(ModuleInstDeleteWaitGroup, self).__init__(
            ModuleRunnerFactory.instance())

    @test
    def wait_for_delete_inst_with_mods(self):
        """Wait until the instance with module is gone."""
        self.test_runner.run_wait_for_delete_inst_with_mods()


@test(depends_on_groups=[groups.MODULE_CREATE],
      runs_after_groups=[groups.MODULE_INST_DELETE_WAIT],
      groups=[GROUP, groups.MODULE_DELETE])
class ModuleDeleteGroup(TestGroup):
    """Test Module Delete functionality."""

    def __init__(self):
        super(ModuleDeleteGroup, self).__init__(
            ModuleRunnerFactory.instance())

    def module_delete_non_existent(self):
        """Ensure delete non-existent module fails."""
        self.test_runner.run_module_delete_non_existent()

    def module_delete_unauth_user(self):
        """Ensure delete module by unauth user fails."""
        self.test_runner.run_module_delete_unauth_user()

    @test(runs_after=[module_delete_unauth_user,
                      module_delete_non_existent])
    def module_delete_hidden_by_non_admin(self):
        """Ensure delete hidden module by non-admin user fails."""
        self.test_runner.run_module_delete_hidden_by_non_admin()

    @test(runs_after=[module_delete_hidden_by_non_admin])
    def module_delete_all_tenant_by_non_admin(self):
        """Ensure delete all tenant module by non-admin user fails."""
        self.test_runner.run_module_delete_all_tenant_by_non_admin()

    @test(runs_after=[module_delete_all_tenant_by_non_admin])
    def module_delete_auto_by_non_admin(self):
        """Ensure delete auto-apply module by non-admin user fails."""
        self.test_runner.run_module_delete_auto_by_non_admin()

    @test(runs_after=[module_delete_auto_by_non_admin])
    def module_delete(self):
        """Check that delete module works."""
        self.test_runner.run_module_delete()

    @test(runs_after=[module_delete])
    def module_delete_admin(self):
        """Check that delete module works for admin."""
        self.test_runner.run_module_delete_admin()

    @test(runs_after=[module_delete_admin])
    def module_delete_remaining(self):
        """Delete all remaining test modules."""
        self.test_runner.run_module_delete_existing()
