def test_insert_5_different_todos(flask_app):
    from app.app import todos_list

    for x in range(ord('a'), ord('e') + 1):
        flask_app.post("/todo", json={"title": chr(x), "due_date": None, "description": f"Descrição todo {chr(x)}"})

    assert len(todos_list) == 5
    assert len(todos_list) == len(set(todos_list))


def test_try_insert_incomplete_todo(flask_app):
    from app.app import todos_list

    # Enviando JSON vazio
    response = flask_app.post("/todo", json={})

    response_data = response.json

    assert response.status_code == 400
    assert response_data["message"]["title"]
    assert response_data["message"]["title"] == "Missing required parameter in the JSON body"
    assert len(todos_list) == 0


def test_insert_5_todos_controller(mock_todo_gen):
    from app.app import todos_list

    for x in range(ord('a'), ord('e') + 1):
        mock_todo_gen(f"todo {chr(x)}", f"Descrição todo {chr(x)}", None)

    assert len(todos_list) == 5
    assert len(todos_list) == len(set(todos_list))


def test_insert_and_remove_todo(flask_app):
    from app.app import todos_list

    # Inserção
    response = flask_app.post("/todo", json={"title":"todo-teste", "description": "descriçao do todo", "due_date": None})

    assert response.status_code == 200
    assert response.json == "inserted"
    assert "todo-teste" in todos_list.keys()

    # Remoção
    response = flask_app.delete("/todo", json={"title": "todo-teste"})

    assert response.status_code == 200
    assert response.json == "deleted"
    assert "todo-teste" not in todos_list.keys()


def test_remove_todo_from_2_existing(mock_todo_gen, flask_app):
    from app.app import todos_list

    mock_todo_gen("todo1", "descrição do 1", None)
    mock_todo_gen("todo2", "descrição do 2", None)

    assert len(todos_list) == 2

    response = flask_app.delete("/todo", json={"title": "todo1"})

    assert response.status_code == 200
    assert response.json == "deleted"
    assert "todo1" not in todos_list.keys()
    assert "todo2" in todos_list.keys()
    assert len(todos_list) == 1


def test_verify_due_date_comportment(mock_todo_gen):
    from app.app import todos_list
    from datetime import datetime

    mock_todo_gen("todo1", "todo com data atual", "14/03/1978")
    assert todos_list["todo1"]["due_date"] == datetime.utcnow().strftime("%d/%m/%Y")

    mock_todo_gen("todo2", "todo com data futura", "14/03/2020")
    assert todos_list["todo2"]["due_date"] == "14/03/2020"

    assert len(todos_list) == 2


def test_try_insert_same_todo(flask_app):
    from app.app import todos_list
    todo_name = "Todo teste"

    flask_app.post("/todo", json={"title": todo_name, "due_date": None, "description": None})
    response = flask_app.post("/todo", json={"title": todo_name, "due_date": None, "description": None})

    assert response.status_code == 500
    assert response.json == f"To Do {todo_name} already exists"
    assert len(todos_list) == 1


def test_try_remove_non_existent_todo(mock_todo_gen, flask_app):
    from app.app import todos_list

    for x in range(ord('a'), ord('c') + 1):
        mock_todo_gen(chr(x), f"descrição {chr(x)}", None)

    assert len(todos_list) == 3

    response = flask_app.delete("/todo", json={"title": "404NotFound"})

    assert response.status_code == 500
    assert response.json == "To Do 404NotFound does not exist"
    assert len(todos_list) == 3

"""
 Teste para inserir (api) 5 ToDos diferentes
"""


def test_insert_to_do(flask_app):
    from app.app import todos_list
    to_do_to_insert = [
        {"title": "TO DO 1", "description": "some description", "due_date": None},
        {"title": "TO DO 2", "description": "some description", "due_date": None},
        {"title": "TO DO 3", "description": "some description", "due_date": None},
        {"title": "TO DO 4", "description": "some description", "due_date": None},
        {"title": "TO DO 5", "description": "some description", "due_date": None}
    ]

    for index, to_do in enumerate(to_do_to_insert):
        response = flask_app.post("/todo", json=to_do)
        response_data = response.json
        assert response.status_code == 200
        assert response_data == "inserted"
        assert len(todos_list) == index + 1
        assert to_do['title'] in todos_list.keys()


"""
 Teste para mandar uma post sem os dados completos
"""


def test_insert_without_all_informations(flask_app):
    from app.app import todos_list
    to_do_to_insert_without_title = {"description": "some description", "due_date": "01/03/2020"},
    to_do_to_insert_without_description = {"title": "Without description", "due_date": "01/03/2020"},
    to_do_to_insert_without_due_date = {"title": "Without deu date", "description": "some description"},
    to_do_to_insert_empty = {},

    from app.app import todos_list

    #  Testing register to do without title
    response = flask_app.post("/todo", json=to_do_to_insert_without_title)

    assert response.status_code == 400
    assert len(todos_list) == 0

    #  Testing register to do without description
    response = flask_app.post("/todo", json=to_do_to_insert_without_description)

    assert response.status_code == 400
    assert len(todos_list) == 0

    #  Testing register to do without due date
    response = flask_app.post("/todo", json=to_do_to_insert_without_due_date)

    assert response.status_code == 400
    assert len(todos_list) == 0

    #  Testing register to do empty
    response = flask_app.post("/todo", json=to_do_to_insert_empty)

    assert response.status_code == 400
    assert len(todos_list) == 0


"""
 Teste para inserir (controller) 5 ToDos diferentes
"""


def test_insert_to_do_controller(mock_todo_gen):
    from app.app import todos_list

    for i in range(1, 6):
        mock_todo_gen(f"TO DO {i}", f"Teste {i}", f"0{i}/12/2020")

    assert len(todos_list) == 5


"""
 Teste para inserir (api) e remover (api) o mesmo ToDo
"""


def test_insert_and_remove_to_do(flask_app):
    from app.app import todos_list

    to_do_to_remove = {"title": "Remove", "description": "some description", "due_date": "01/01/2020"}
    to_do_to_keep = {"title": "Keep", "description": "some description", "due_date": "01/01/2020"}

    # Inserting to do to remove
    response = flask_app.post("/todo", json=to_do_to_remove)
    response_data = response.json
    assert response.status_code == 200
    assert response_data == "inserted"
    assert len(todos_list) == 1
    assert to_do_to_remove['title'] in todos_list.keys()

    #  Inserting a to do to keep in list
    response = flask_app.post("/todo", json=to_do_to_keep)
    response_data = response.json
    assert response.status_code == 200
    assert response_data == "inserted"
    assert len(todos_list) == 2
    assert to_do_to_keep['title'] in todos_list.keys()

    #  Deleting to_do_to_remove from list
    response = flask_app.delete("/todo", json={"title": to_do_to_remove['title']})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "deleted"
    assert len(todos_list) == 1
    assert to_do_to_remove['title'] not in todos_list.keys()
    assert to_do_to_keep['title'] in todos_list.keys()


"""
 Teste para, ja existindo 2 todos, remover (api) um deles
"""


def test_remove_to_do_api(flask_app, mock_todo_gen):
    from app.app import todos_list

    keep = "Keep"
    remove = "Remove"

    #  inserting to do
    mock_todo_gen(keep, "Teste", "01/12/2020")
    mock_todo_gen(remove, "Teste", "02/12/2020")

    #  Deleting one of to do from list using API
    response = flask_app.delete("/todo", json={"title": "Remove"})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "deleted"
    assert len(todos_list) == 1
    assert remove not in todos_list.keys()
    assert keep in todos_list.keys()


"""
 Teste para inserir 2 ToDos (api) e verificar o comportamento do due_date
  (se antes que hoje, ele vai virar hoje, se não ele insere como foi mandado)
"""


def test_due_date_behavior_on_insert_to_do(flask_app):
    from app.app import todos_list
    import datetime

    today = datetime.datetime.now()
    two_day = datetime.timedelta(days=2)
    date_after = today + two_day
    date_before = today - two_day

    to_do_date_after_today = {"title": "After", "description": "some description", "due_date": date_after.strftime("%d/%m/%Y")}
    to_do_date_before_today = {"title": "Before", "description": "some description", "due_date": date_before.strftime("%d/%m/%Y")}

    # Inserting to do to remove
    response = flask_app.post("/todo", json=to_do_date_after_today)
    response_data = response.json
    assert response.status_code == 200
    assert response_data == "inserted"
    assert len(todos_list) == 1
    assert to_do_date_after_today['title'] in todos_list.keys()

    #  Inserting a to do to keep in list
    response = flask_app.post("/todo", json=to_do_date_before_today)
    response_data = response.json
    assert response.status_code == 200
    assert response_data == "inserted"
    assert len(todos_list) == 2
    assert to_do_date_before_today['title'] in todos_list.keys()

    # Checking if date before was changed on register
    to_do_with_date_updated_to_today = todos_list[to_do_date_before_today['title']]
    assert to_do_with_date_updated_to_today['due_date'] == today.strftime("%d/%m/%Y")

    #  Cheking if date after was changed on register
    to_do_after_from_list = todos_list[to_do_date_after_today['title']]
    assert to_do_after_from_list['due_date'] == date_after.strftime("%d/%m/%Y")


"""
 Teste para inserir (api) 2 ToDos iguais
"""


def test_insert_with_api_two_to_do_with_same_title(flask_app):
    from app.app import todos_list

    to_do_to_insert = {"title": "Same title", "description": "some description", "due_date": "01/01/2020"}

    # Inserting valid to do using api
    response = flask_app.post("/todo", json=to_do_to_insert)
    response_data = response.json
    assert response.status_code == 200
    assert response_data == "inserted"
    assert len(todos_list) == 1
    assert to_do_to_insert['title'] in todos_list.keys()

    #  Inserting a invalid to do to on using api
    response = flask_app.post("/todo", json=to_do_to_insert)
    response_data = response.json
    assert response.status_code == 500
    assert response_data == f"To Do {to_do_to_insert['title']} already exists"
    assert len(todos_list) == 1


"""
 Teste para, tendo 3 ToDos, tentar remover um que não existe
"""


def test_remove_to_do_that_not_exists(mock_todo_gen, flask_app):
    from app.app import todos_list
    to_do_to_remove = {"title": "Não existente"}

    for i in range(1, 4):
        mock_todo_gen(f"TO DO {i}", f"Teste {i}", f"0{i}/12/2020")

    assert len(todos_list) == 3

    response = flask_app.delete("/todo", json=to_do_to_remove)
    response_data = response.json
    assert response.status_code == 500
    assert response_data == f"To Do {to_do_to_remove['title']} does not exist"
    assert len(todos_list) == 3

import pytest


@pytest.fixture(params=["tomar banho", "fazer numero 1", "fazer numero 2", "comprar comida", "morrer"])
def tarefa(request):
    return request.param


"""
 Teste para inserir (api) 5 ToDos diferentes
"""


def test_insert_5_todos_api(flask_app, tarefa):
    from app.app import todos_list

    response = flask_app.post("/todo", json={"title": f"tarefa {tarefa}"})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "inserted"
    assert f"tarefa {tarefa}" in todos_list.keys()


"""
 Teste para mandar uma post sem os dados completos
"""


def test_insert_todo_wrong(flask_app):
    response = flask_app.post("/todo", json={})
    assert response.status_code == 400


"""
 Teste para inserir (controller) 5 ToDos diferentes
"""


def test_add_5_todos_controller(tarefa):
    from app.controllers import insert_todo

    success = insert_todo(f"tarefa {tarefa}")
    assert success is True, success


"""
 Teste para inserir (api) e remover (api) o mesmo ToDo
"""


def test_insert_and_delete_todo(flask_app):
    from app.app import todos_list

    response = flask_app.post("/todo", json={"title": "ir correr de manhã"})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "inserted"
    assert "ir correr de manhã" in todos_list.keys()

    response = flask_app.delete("/todo", json={"title": "ir correr de manhã"})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "deleted"

    todo_in_list = "ir correr de manhã" in todos_list.keys()
    assert todo_in_list is False


"""
 Teste para, ja existindo 2 todos, remover (api) um deles
"""


def test_delete_todo_already_in_list(flask_app, mock_todo_gen):
    from app.app import todos_list

    mock_todo_gen("primeiro todo", "é o primeiro", "08/03/2020")
    mock_todo_gen("segundo todo", "é o segundo", "08/03/2020")

    response = flask_app.delete("/todo", json={"title": "primeiro todo"})
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "deleted"

    todos_titles = todos_list.keys()
    first_in_todos = "primeiro todo" in todos_titles
    second_in_todos = "segundo todo" in todos_titles
    assert first_in_todos is False
    assert second_in_todos is True


"""
 Teste para inserir 2 ToDos (api) e verificar o comportamento do due_date
  (se antes que hoje, ele vai virar hoje, se não ele insere como foi mandado)
"""


def test_due_date_logic(flask_app, monkeypatch):
    from app.app import todos_list
    from app import controllers
    from datetime import datetime

    arbitrary_today = "10/03/2020"

    def get_time_now_faked():
        return datetime.strptime(arbitrary_today, "%d/%m/%Y")

    monkeypatch.setattr(controllers, "get_time_now", get_time_now_faked)

    title_01 = "teste 01"
    title_02 = "teste 02"

    arbitrary_yesterday = "09/03/2020"

    flask_app.post("/todo", json={"title": title_01, "due_date": arbitrary_today})
    flask_app.post("/todo", json={"title": title_02, "due_date": arbitrary_yesterday})

    assert todos_list[title_01]['due_date'] == arbitrary_today
    assert todos_list[title_02]['due_date'] == arbitrary_today


"""
 Teste para inserir (api) 2 ToDos iguais
"""


def test_equal_todos(flask_app):
    from app.app import todos_list

    same_todo = {"title": "igual"}

    flask_app.post("/todo", json=same_todo)
    response = flask_app.post("/todo", json=same_todo)
    response_data = response.json

    assert response.status_code == 500
    assert response_data == f"To Do {same_todo['title']} already exists"


"""
 Teste para, tendo 3 ToDos, tentar remover um que não existe
"""


def test_remove_todo_not_exist(flask_app, mock_todo_gen):
    from app.app import todos_list
    from app.controllers import remove_todo

    mock_todo_gen("primeiro todo", "é o primeiro", "08/03/2020")
    mock_todo_gen("segundo todo", "é o segundo", "08/03/2020")
    mock_todo_gen("terceiro todo", "é o segundo", "08/03/2020")

    res = remove_todo("quarto")
    assert res == "To Do quarto does not exist"

def test_insert_todos_by_api(flask_app):
    """
        Teste para inserir (api) 5 ToDos diferentes
    """
    from app.app import todos_list
    from pprint import pprint

    for i in range(1, 6):
        response = flask_app.post(
            "/todo",
            json={"title": f"tarefa {i}", "description": f"{i}° teste do post",},
        )
        response_data = response.json

        assert response.status_code == 200
        assert response_data == "inserted"
        assert len(todos_list) == i
        assert f"tarefa {i}" in todos_list.keys()

    pprint(todos_list)


def test_insert_todos_without_params(flask_app):
    """
         Teste para mandar uma post sem os dados completos
         Neste caso, o status code deve ser 400
    """
    from app.app import todos_list

    response = flask_app.post("/todo", json={},)

    assert response.status_code == 400
    assert len(todos_list) == 0


def test_insert_todos_by_controller(flask_app):
    """
        Teste para inserir (controller) 5 ToDos diferentes
    """
    from app.controllers import insert_todo
    from app.app import todos_list
    from pprint import pprint

    for index in range(1, 6):
        result = insert_todo(title=f"tarefa {index}", description=f"Inserindo tarefa {index}")
        assert result == True
        assert len(todos_list) == index
        assert f"tarefa {index}" in todos_list.keys()

    pprint(todos_list)


def test_remove_todo_by_api(flask_app):
    """
        Teste para inserir (api) e remover (api) o mesmo ToDo
    """
    from app.controllers import insert_todo
    from app.app import todos_list
    from pprint import pprint

    # Inserindo um novo ToDo através da api
    title = "tarefa teste"
    _ = flask_app.post(
        "/todo",
        json={"title": title, "description": "tarefa a ser removida"},
    )

    # Removendo o ToDo criado anteriormente através da api

    response = flask_app.delete(
        "/todo",
        json={"title": title},
    )
    response_data = response.json

    assert response.status_code == 200
    assert response_data == "deleted"
    assert len(todos_list) == 0
    assert title not in todos_list.keys()


"""
 Teste para, ja existindo 2 todos, remover (api) um deles
"""

"""
 Teste para inserir 2 ToDos (api) e verificar o comportamento do due_date
  (se antes que hoje, ele vai virar hoje, se não ele insere como foi mandado)
"""

"""
 Teste para inserir (api) 2 ToDos iguais
"""

"""
 Teste para, tendo 3 ToDos, tentar remover um que não existe
"""