AD TESTS

app.py

import appdaemon.plugins.hass.hassapi as hass
import datetime


def timer_cb(kwargs):
    print('timer_cb {}'.format(kwargs))

TESTS_RUN_AND_DONE = [
    'list_namespaces',
    'sun_up',
    'sun_down',
    'sunrise',
    'sunset',
    # 'get_thread_info',
    'time',
    'date',
]

TESTS_RUN_AND_DONE_QUIET = [
    'get_scheduler_entries',
    'get_callback_entries',
]

TESTS_RUN_WITH_ARGS_AND_DONE = [
    {
        'fn': 'get_state',
        'args': ['sun.sun'],
        'kwargs': {
            'attribute': 'state'
        }
    },
    {
        'fn': 'set_state',
        'args': ['sensor.test'],
        'kwargs': {
            'state': 'test'
        }
    },
    {
        'fn': 'parse_time',
        'args': ['12:34:56']
    },
    {
        'fn': 'parse_datetime',
        'args': ['2020-01-02 03:45:56']
    },
]

TESTS_RUN_WITH_ARGS_AND_TESTNAME_AND_DONE = [
    {
        'fn': 'run_in',
        'args': [timer_cb, 0],
    },
    {
        'fn': 'run_at_sunset',
        'args': [timer_cb],
    },
    {
        'fn': 'run_at_sunrise',
        'args': [timer_cb],
    },
    {
        'fn': 'run_at',
        'args': [
            timer_cb,
            (datetime.datetime.now() + datetime.timedelta(minutes=1)),
        ]
    },
    {
        'fn': 'run_once',
        'args': [
            timer_cb,
            datetime.datetime.now().time()
        ]
    },
    {
        'fn': 'run_daily',
        'args': [
            timer_cb,
            (datetime.datetime.now() + datetime.timedelta(minutes=1)).time(),
        ]
    },
    {
        'fn': 'run_hourly',
        'args': [
            timer_cb,
            (datetime.datetime.now() + datetime.timedelta(minutes=1)).time(),
            # datetime.datetime.now().time(),
        ]
    },
    {
        'fn': 'run_minutely',
        'args': [
            timer_cb,
            (datetime.datetime.now() + datetime.timedelta(seconds=5)).time(),
            # datetime.datetime.now().time(),
        ]
    },
    {
        'fn': 'run_every',
        'args': [
            timer_cb,
            datetime.datetime.now() + datetime.timedelta(minutes=1),
            # datetime.datetime.now(),
            60,
        ]
    },
]


class AsyncTest(hass.Hass):
    async def initialize(self):
        await self.run_and_done()
        await self.run_and_done_quiet()
        await self.run_with_args_and_done()
        await self.run_with_args_and_testname_and_done()

    async def run_and_done(self):
        things = TESTS_RUN_AND_DONE

        for t in things:
            fn = getattr(self, t)
            ret = await fn()
            self.log("{} {}".format(t, ret))

    async def run_and_done_quiet(self):
        things = TESTS_RUN_AND_DONE_QUIET

        for t in things:
            fn = getattr(self, t)
            ret = await fn()
            self.log("{} {}".format(t, len(ret)))

    async def run_with_args_and_done(self):
        things = TESTS_RUN_WITH_ARGS_AND_DONE

        for t in things:
            fn = getattr(self, t['fn'])
            args = t.get('args', [])
            kwargs = t.get('kwargs', {})
            ret = await fn(*args, **kwargs)
            self.log("{} {}".format(t['fn'], ret))

    async def run_with_args_and_testname_and_done(self):
        things = TESTS_RUN_WITH_ARGS_AND_TESTNAME_AND_DONE

        for t in things:
            fn = getattr(self, t['fn'])
            args = t.get('args', [])
            kwargs = t.get('kwargs', {})
            kwargs['test_name'] = t['fn']
            self.log("CALL {} {} {}".format(fn, args, kwargs))
            ret = await fn(*args, **kwargs)
            self.log("{} {}".format(t['fn'], ret))


class SyncTest(hass.Hass):
    def initialize(self):
        self.run_and_done()
        self.run_and_done_quiet()
        self.run_with_args_and_done()
        self.run_with_args_and_testname_and_done()

    def run_and_done(self):
        things = TESTS_RUN_AND_DONE

        for t in things:
            fn = getattr(self, t)
            ret = fn()
            self.log("{} {}".format(t, ret))

    def run_and_done_quiet(self):
        things = TESTS_RUN_AND_DONE_QUIET

        for t in things:
            fn = getattr(self, t)
            ret = fn()
            self.log("{} {}".format(t, len(ret)))

    def run_with_args_and_done(self):
        things = TESTS_RUN_WITH_ARGS_AND_DONE

        for t in things:
            fn = getattr(self, t['fn'])
            args = t.get('args', [])
            kwargs = t.get('kwargs', {})
            ret = fn(*args, **kwargs)
            self.log("{} {}".format(t['fn'], ret))

    def run_with_args_and_testname_and_done(self):
        things = TESTS_RUN_WITH_ARGS_AND_TESTNAME_AND_DONE

        for t in things:
            fn = getattr(self, t['fn'])
            args = t.get('args', [])
            kwargs = t.get('kwargs', {})
            kwargs['test_name'] = t['fn']
            self.log("CALL {} {} {}".format(fn, args, kwargs))
            ret = fn(*args, **kwargs)
            self.log("{} {}".format(t['fn'], ret))