Live 80 beta

fake.py

"""Providers para o faker."""
from random import choice
from faker import Faker
from faker.providers import BaseProvider


class Task(BaseProvider):
    """Model to provide tasks."""

    def task_name(self):
        return choice(
            [
                'Dormir',
                'Acordar',
                'Ligar pro Will',
                'Sair de casa',
                'Tomar remédio',
            ]
        )

    def state(self):
        return choice(['TODO', 'Doing', 'Done'])

    def id(self):
        return self.random_int(1, 1000)

    def task(self):
        return {
            'id': self.id(),
            'task_name': self.task_name(),
            'state': self.state(),
        }

    def task_list(self, n):
        return [self.task() for x in range(0, n)]


fake = Faker()
fake.add_provider(Task)

serializador.py

from itertools import count

c = count()

db = []


class Task:
    """Uma classe típica de modelos de bancos de dados."""

    def __init__(self, task_name: str, state: str = 'TODO', *, id_: int = None):
        self.id_ = id_ or next(c)
        self.task_name = task_name
        self.state = state

    def __repr__(self):
        return f'Task(task_name="{self.task_name}", state="{self.state}")'


"""
Serializers.
"""
def task_serializer(task: Task) -> dict:
    """Faz a serialização de uma Task em um dict."""
    return {'task_name': task.task_name, 'state': task.state}


def task_unserializer(task: dict) -> Task:
    """Faz a serialização de uma Task em um dict."""
    return Task(task['task_name'], task['state'])


"""
Database Utils.
"""
def dump_db(db, serializer):
    return [serializer(obj) for obj in db]


def load_db(db, unserializer):
    return [unserializer(obj) for obj in db]



def query(id_=None, task_name=None, state=None):
    func = (
        lambda data: data.id_ == id_
        or data.task_name == task_name
        or data.state == state
    )
    return list(filter(func, db))

test.py

from unittest import TestCase, main
from faker import Faker

from serializador import Task, task_serializer

f = Faker()


class TestModelTask(TestCase):
    def test_check_model_representation(self):
        esperado = f'Task(task_name="Acordar", state="DONE")'
        chamada = Task('Acordar', 'DONE')

        self.assertEqual(esperado, str(chamada))

    def test_check_model_has_id_and_his_is_int(self):
        self.assertIsInstance(Task('Acordar', 'DONE').id_, int)


class TestTaskSerializer(TestCase):
    def test_task_serializer_deve_ser_um_dict(self):
        task_name = 'Ligar para o will'
        state = 'TODO'
        task = Task(task_name, state)

        self.assertIsInstance(task_serializer(task), dict)


if __name__ == '__main__':
    main()