예제 #1
0
파일: __init__.py 프로젝트: pyapp-org/pyapp
    def check_definition(self, config_definitions: Dict[str, Dict[str, Any]],
                         name: str, **_):
        """
        Checks for individual definitions.
        """
        definition = config_definitions[name]
        if not isinstance(definition, dict):
            return checks.Critical(
                "Config definition entry is not a dict.",
                hint="Change definition to be a dict in settings.",
                obj=f"settings.{self.setting}[{name}]",
            )

        messages = []

        # Check required definitions exist
        for key in self.required_keys:
            if key not in definition:
                messages.append(
                    checks.Critical(
                        f"Config definition entry does not contain `{key}` value.",
                        obj=f"settings.{self.setting}[{name}]",
                    ))

        # Check for un-known values
        if self._args:
            for key in definition:
                if key not in self._args:
                    messages.append(
                        checks.Warn(
                            f"Config definition entry contains unknown value `{key}`.",
                            obj=f"settings.{self.setting}[{name}][{key}]",
                        ))

        return messages
예제 #2
0
    def checks(self, **kwargs):
        """
        Run checks to ensure settings are valid, secondly run checks against
        individual definitions in settings.
        """
        settings_ = kwargs['settings']

        # Check settings are defined
        if not hasattr(settings_, self.setting):
            return checks.Critical(
                "Instance definitions missing from settings.",
                hint="Add a {} entry into settings.".format(self.setting),
                obj="settings.{}".format(self.setting))

        instance_definitions = getattr(settings_, self.setting)
        if instance_definitions is None:
            return  # Nothing is defined so end now.

        if not isinstance(instance_definitions, dict):
            return checks.Critical(
                "Instance definitions defined in settings not a dict instance.",
                hint="Change setting {} to be a dict in settings file.".format(
                    self.setting),
                obj="settings.{}".format(self.setting))

        # Take over the lock while checks are being performed
        with self._type_definitions_lock:
            # Backup definitions, replace and clear cache, this is to make it
            # easier to write checks for instances.
            instance_definitions_orig = self._instance_definitions
            try:
                self._instance_definitions = instance_definitions
                self._type_definitions.clear()

                messages = []

                # Check default is defined
                if self.default_name not in instance_definitions:
                    messages.append(
                        checks.Warn(
                            "Default definition not defined.",
                            hint="The default instance type `{}` is not defined."
                            .format(self.default_name),
                            obj="settings.{}".format(self.setting)))

                # Check instance definitions
                for name in instance_definitions:
                    message = self.check_instance(instance_definitions, name,
                                                  **kwargs)
                    if isinstance(message, checks.CheckMessage):
                        messages.append(message)
                    elif message:
                        messages += message

                return messages

            finally:
                # Put definitions back and clear cache.
                self._instance_definitions = instance_definitions_orig
                self._type_definitions.clear()
예제 #3
0
파일: __init__.py 프로젝트: pyapp-org/pyapp
    def checks(self, **kwargs):
        """
        Run checks to ensure settings are valid, secondly run checks against
        individual definitions in settings.

        """
        settings_ = kwargs["settings"]

        # Check settings are defined
        if not hasattr(settings_, self.setting):
            return checks.Critical(
                "Config definitions missing from settings.",
                hint=f"Add a {self.setting} entry into settings.",
                obj=f"settings.{self.setting}",
            )

        config_definitions = getattr(settings_, self.setting)
        if config_definitions is None:
            return None  # Nothing is defined so end now.

        if not isinstance(config_definitions, dict):
            return checks.Critical(
                "Config definitions defined in settings not a dict instance.",
                hint=
                f"Change setting {self.setting} to be a dict in settings file.",
                obj=f"settings.{self.setting}",
            )

        messages = []

        # Check default is defined
        if self.default_name not in config_definitions:
            messages.append(
                checks.Warn(
                    "Default definition not defined.",
                    hint=f"Add a `{self.default_name}` entry.",
                    obj=f"settings.{self.setting}",
                ))

        # Check instance definitions
        for name in config_definitions:
            message = self.check_definition(config_definitions, name, **kwargs)
            if isinstance(message, checks.CheckMessage):
                messages.append(message)
            elif message:
                messages += message

        return messages
예제 #4
0
    def check_instance(self, idx, provider_ref, **_):
        """
        Checks for individual providers.
        """
        if not isinstance(provider_ref, six.string_types):
            return checks.Critical(
                "Provider definition is not a string.",
                hint="Change definition to be a string in settings.",
                obj='settings.{}[{}]'.format(self.setting, idx))

        try:
            import_type(provider_ref)
        except ImportError as ex:
            return checks.Critical("Unable to import provider type.",
                                   hint=str(ex),
                                   obj='settings.{}[{}]'.format(
                                       self.setting, idx))
    def test_checks__missing_settings(self):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            del ctx.TEST_PROVIDERS

            actual = target.checks(settings=settings)

            assert actual == checks.Critical(
                u"Provider definitions missing from settings.",
                u"Add a TEST_PROVIDERS entry into settings.",
                u"settings.TEST_PROVIDERS")
예제 #6
0
    def checks(self, **kwargs):
        """
        Run checks to ensure settings are valid, secondly run checks against
        individual definitions in settings.

        """
        settings_ = kwargs["settings"]

        # Check settings are defined
        if not hasattr(settings_, self.setting):
            return checks.Critical(
                "Provider definitions missing from settings.",
                hint=f"Add a {self.setting} entry into settings.",
                obj=f"settings.{self.setting}",
            )

        provider_refs = getattr(settings_, self.setting)
        if provider_refs is None:
            return None  # Nothing is defined so end now.

        if not isinstance(provider_refs, (list, tuple)):
            return checks.Critical(
                "Provider definitions defined in settings not a list/tuple instance.",
                hint=
                f"Change setting {self.setting} to be a list or tuple in settings file.",
                obj=f"settings.{self.setting}",
            )

        messages = []

        for idx, provider_ref in enumerate(provider_refs):
            message = self.check_instance(idx, provider_ref, **kwargs)
            if isinstance(message, checks.CheckMessage):
                messages.append(message)
            elif message:
                messages.extend(message)

        return messages
예제 #7
0
    def check_instance(self, instance_definitions, name, **_):
        """
        Checks for individual instances.
        """
        definition = instance_definitions[name]
        if not isinstance(definition, (tuple, list)):
            return checks.Critical(
                "Instance definition is not a list/tuple.",
                hint=
                "Change definition to be a list/tuple (type_name, kwargs) in settings.",
                obj='settings.{}[{}]'.format(self.setting, name))

        if len(definition) != 2:
            return checks.Critical(
                "Instance definition is not a type name, kwarg (dict) pair.",
                hint=
                "Change definition to be a list/tuple (type_name, kwargs) in settings.",
                obj='settings.{}[{}]'.format(self.setting, name))

        type_name, kwargs = definition
        messages = []

        try:
            import_type(type_name)
        except (ImportError, ValueError):
            messages.append(
                checks.Error("Unable to import type `{}`.".format(type_name),
                             hint="Check the type name in definition.",
                             obj='settings.{}[{}]'.format(self.setting, name)))

        if not isinstance(kwargs, dict):
            messages.append(
                checks.Critical("Instance kwargs is not a dict.",
                                hint="Change kwargs definition to be a dict.",
                                obj='settings.{}[{}]'.format(
                                    self.setting, name)))

        return messages
예제 #8
0
    def check_definition(self, config_definitions, name, **_):
        """
        Checks for individual definitions.

        :param config_definitions:
        :param name:
        :return:

        """
        definition = config_definitions[name]
        if not isinstance(definition, dict):
            return checks.Critical(
                "Config definition entry is not a dict.",
                hint="Change definition to be a dict in settings.",
                obj='settings.{}[{}]'.format(self.setting, name)
            )

        messages = []

        # Check required definitions exist
        for key in self.required_keys:
            if key not in definition:
                messages.append(checks.Critical(
                    "Config definition entry does not contain `{}` value.".format(key),
                    obj='settings.{}[{}]'.format(self.setting, name)
                ))

        # Check for un-known values
        if self._args:
            for key in definition:
                if key not in self._args:
                    messages.append(checks.Warn(
                        "Config definition entry contains unknown value `{}`.".format(key),
                        obj='settings.{}[{}][{}]'.format(self.setting, name, key)
                    ))

        return messages
예제 #9
0
    def check_instance(
        self, idx: int, provider_ref: str, **_
    ) -> Optional[Union["checks.CheckMessage",
                        Sequence["checks.CheckMessage"]]]:
        """
        Checks for individual providers.
        """
        if not isinstance(provider_ref, str):
            return checks.Critical(
                "Provider definition is not a string.",
                hint="Change definition to be a string in settings.",
                obj=f"settings.{self.setting}[{idx}]",
            )

        try:
            import_type(provider_ref)
        except ImportError as ex:
            return checks.Critical(
                "Unable to import provider type.",
                hint=str(ex),
                obj=f"settings.{self.setting}[{idx}]",
            )

        return None
예제 #10
0
파일: __main__.py 프로젝트: pyapp-org/pyapp
def critical_check(**_):
    return checks.Critical(
        "Critical message, that is really really long and should be wrapped across lines. Actually across two no THREE "
        "lines! Now that is getting fairly full on! :)",
        "Remove critical messages",
    )
예제 #11
0
class TestProviderFactoryBase(object):
    def test_providers(self):
        target = ProviderFactoryTest()
        actual = target.providers

        assert len(actual) == 1

    def test_provider_summaries(self):
        target = ProviderFactoryTest()
        actual = target.provider_summaries

        assert len(actual) == 1
        assert actual == [
            providers.ProviderSummary(
                'tests.test_conf_helpers_providers.ProviderBaseTest',
                "Test Provider", "Description.")
        ]

    def test_get_provider(self):
        target = ProviderFactoryTest()
        actual = target.get_provider(
            'tests.test_conf_helpers_providers.ProviderBaseTest')

        assert actual is ProviderBaseTest

    def test_get_provider__not_found(self):
        target = ProviderFactoryTest()

        with pytest.raises(providers.ProviderNotFound):
            target.get_provider('tests.wrong.ProviderBaseTest')

    def test_get_instance(self):
        target = ProviderFactoryTest(
            'tests.test_conf_helpers_providers.ProviderBaseTest',
            {'foo': 'bar'})

        actual = target()

        assert isinstance(actual, ProviderBaseTest)
        assert actual.foo == 'bar'

    def test_get_instance__not_found(self):
        target = ProviderFactoryTest('tests.wrong.ProviderBaseTest')

        with pytest.raises(providers.ProviderNotFound):
            target()

    @pytest.mark.parametrize('provider_settings, expected', ((None, None), (
        [], []
    ), ({},
        checks.Critical(
            u"Provider definitions defined in settings not a list/tuple instance.",
            u"Change setting TEST_PROVIDERS to be a list or tuple in settings file.",
            u"settings.TEST_PROVIDERS")), ([
                'tests.test_conf_helpers_providers.ProviderBaseTest'
            ], []), ([123], [
                checks.Critical(
                    u"Provider definition is not a string.",
                    u"Change definition to be a string in settings.",
                    u"settings.TEST_PROVIDERS[0]")
            ])))
    def test_checks(self, provider_settings, expected):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            ctx.TEST_PROVIDERS = provider_settings

            actual = target.checks(settings=settings)

            assert actual == expected

    def test_checks__missing_settings(self):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            del ctx.TEST_PROVIDERS

            actual = target.checks(settings=settings)

            assert actual == checks.Critical(
                u"Provider definitions missing from settings.",
                u"Add a TEST_PROVIDERS entry into settings.",
                u"settings.TEST_PROVIDERS")

    def test_checks__invalid_import(self):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            ctx.TEST_PROVIDERS = [
                'tests.test_conf_helpers_providers.ProviderBaseTest',
                'tests.wrong.ProviderBaseTest'
            ]

            actual = target.checks(settings=settings)[0]

            assert isinstance(actual, checks.Critical)
            assert actual.msg == u"Unable to import provider type."
            assert actual.obj == u"settings.TEST_PROVIDERS[1]"
예제 #12
0
class TestProviderFactoryBase:
    def test_providers(self):
        target = ProviderFactoryTest()
        actual = target.providers

        assert len(actual) == 1

    def test_provider_summaries(self):
        target = ProviderFactoryTest()
        actual = target.provider_summaries

        assert len(actual) == 1
        assert actual == (
            providers.ProviderSummary(
                "tests.conf.helpers.test_providers.ProviderBaseTest",
                "Test Provider",
                "Description.",
            ),
        )

    def test_get_provider(self):
        target = ProviderFactoryTest()
        actual = target.get_provider(
            "tests.conf.helpers.test_providers.ProviderBaseTest"
        )

        assert actual is ProviderBaseTest

    def test_get_provider__not_found(self):
        target = ProviderFactoryTest()

        with pytest.raises(providers.ProviderNotFound):
            target.get_provider("tests.wrong.ProviderBaseTest")

    def test_get_instance(self):
        target = ProviderFactoryTest(
            "tests.conf.helpers.test_providers.ProviderBaseTest", {"foo": "bar"}
        )

        actual = target.create()

        assert isinstance(actual, ProviderBaseTest)
        assert actual.foo == "bar"

    def test_get_instance__not_found(self):
        target = ProviderFactoryTest("tests.wrong.ProviderBaseTest")

        with pytest.raises(providers.ProviderNotFound):
            target.create()

    @pytest.mark.parametrize(
        "provider_settings, expected",
        (
            (None, None),
            ([], []),
            (
                {},
                checks.Critical(
                    u"Provider definitions defined in settings not a list/tuple instance.",
                    u"Change setting TEST_PROVIDERS to be a list or tuple in settings file.",
                    u"settings.TEST_PROVIDERS",
                ),
            ),
            (["tests.conf.helpers.test_providers.ProviderBaseTest"], []),
            (
                [123],
                [
                    checks.Critical(
                        u"Provider definition is not a string.",
                        u"Change definition to be a string in settings.",
                        u"settings.TEST_PROVIDERS[0]",
                    )
                ],
            ),
        ),
    )
    def test_checks(self, provider_settings, expected):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            ctx.TEST_PROVIDERS = provider_settings

            actual = target.checks(settings=settings)

            assert actual == expected

    def test_checks__multiple_instance_messages(self):
        target = ProviderFactoryTest(multi_messages=True)

        with settings.modify() as ctx:
            ctx.TEST_PROVIDERS = ("tests.conf.helpers.test_providers.ProviderBaseTest",)

            actual = target.checks(settings=settings)

            assert actual == [checks.Info("foo"), checks.Warn("bar")]

    def test_checks__missing_settings(self):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            del ctx.TEST_PROVIDERS

            actual = target.checks(settings=settings)

            assert actual == checks.Critical(
                u"Provider definitions missing from settings.",
                u"Add a TEST_PROVIDERS entry into settings.",
                u"settings.TEST_PROVIDERS",
            )

    def test_checks__invalid_import(self):
        target = ProviderFactoryTest()

        with settings.modify() as ctx:
            ctx.TEST_PROVIDERS = [
                "tests.conf.helpers.test_providers.ProviderBaseTest",
                "tests.wrong.ProviderBaseTest",
            ]

            actual = target.checks(settings=settings)[0]

            assert isinstance(actual, checks.Critical)
            assert actual.msg == u"Unable to import provider type."
            assert actual.obj == u"settings.TEST_PROVIDERS[1]"
예제 #13
0
파일: plugins.py 프로젝트: pyapp-org/pyapp
    def check_instance(self, instance_definitions, name, **_):
        """
        Checks for individual instances.
        """
        definition = instance_definitions[name]
        if not isinstance(definition, (tuple, list)):
            return checks.Critical(
                "Instance definition is not a list/tuple.",
                hint=
                "Change definition to be a list/tuple (type_name, kwargs) in settings.",
                obj=f"settings.{self.setting}[{name}]",
            )

        if len(definition) != 2:
            return checks.Critical(
                "Instance definition is not a type name, kwarg (dict) pair.",
                hint=
                "Change definition to be a list/tuple (type_name, kwargs) in settings.",
                obj=f"settings.{self.setting}[{name}]",
            )

        type_name, kwargs = definition
        messages = []

        if type_name.upper() == "ALIAS":
            target_name = kwargs.get("name")
            if not target_name:
                messages.append(
                    checks.Critical(
                        "Name of alias target not defined",
                        hint=
                        "An alias entry must provide a `name` value that refers to another entry.",
                        obj=f"settings.{self.setting}[{name}]",
                    ))

            elif target_name not in instance_definitions:
                messages.append(
                    checks.Critical(
                        "Alias target not defined",
                        hint=
                        "The target specified by the alias does not exist, check the `name` value.",
                        obj=f"settings.{self.setting}[{name}][{target_name}]",
                    ))

            if len(kwargs) > 1:
                messages.append(
                    checks.Warn(
                        "Alias contains unknown arguments",
                        hint="An alias entry must only provide a `name` value.",
                        obj=f"settings.{self.setting}[{name}]",
                    ))

        else:
            try:
                import_type(type_name)
            except (ImportError, ValueError, AttributeError):
                messages.append(
                    checks.Error(
                        f"Unable to import type `{type_name}`.",
                        hint="Check the type name in definition.",
                        obj=f"settings.{self.setting}[{name}]",
                    ))

            if not isinstance(kwargs, dict):
                messages.append(
                    checks.Critical(
                        "Instance kwargs is not a dict.",
                        hint="Change kwargs definition to be a dict.",
                        obj=f"settings.{self.setting}[{name}]",
                    ))

        return messages