requests-api-testing/conftest.py at main · qam1s/requests-api-testing · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
from typing import Generator

import pytest
from pydentic import BaseModel

from helpers.db import DBConnector
from services.comments.comments import CommentsService
from services.comments.models import CommentModel
from services.pages.pages import PagesService
from services.pages.models import PageModel
from services.posts.posts import PostsService
from services.posts.models import PostModel
from services.users.users import UsersService
from services.users.models import UserModel


@pytest.fixture(scope="session", autouse=True)
def db() -> Generator[DBConnector, None, None]:
    db = DBConnector()
    yield db
    db.disconnect()


# comments

@pytest.fixture()
def comments_service() -> CommentsService:
    comments_service = CommentsService()
    return comments_service


@pytest.fixture()
def create_comment(
    comments_service: CommentsService, delete_post: PostModel
) -> CommentModel:
    return comments_service.create_comment(delete_post.model.id)


@pytest.fixture()
def delete_comment(
    comments_service: CommentsService, create_comment: CommentModel
) -> Generator[CommentModel, None, None]:
    yield create_comment
    comments_service.delete_comment(create_comment.model.id)


@pytest.fixture()
def create_comment_by_db(db: DBConnector) -> Generator[BaseModel, None, None]:
    comment = db.create_comment()
    yield comment
    db.delete_comment(comment.id)


# pages

@pytest.fixture()
def pages_service() -> PagesService:
    pages_service = PagesService()
    return pages_service


@pytest.fixture()
def create_page(pages_service: PagesService) -> PageModel:
    return pages_service.create_page()


@pytest.fixture()
def delete_page(
    pages_service: PagesService, create_page: PageModel
) -> Generator[PageModel, None, None]:
    yield create_page
    pages_service.delete_page(create_page.model.id)


@pytest.fixture()
def create_page_by_db(db: DBConnector) -> Generator[BaseModel, None, None]:
    page = db.create_page()
    yield page
    db.delete_page(page.id)


# posts

@pytest.fixture()
def posts_service() -> PostsService:
    posts_service = PostsService()
    return posts_service


@pytest.fixture()
def create_post(posts_service: PostsService) -> PostModel:
    return posts_service.create_post()


@pytest.fixture()
def delete_post(
    posts_service: PostsService, create_post: PostModel
) -> Generator[PostModel, None, None]:
    yield create_post
    posts_service.delete_post(create_post.model.id)


@pytest.fixture()
def create_post_by_db(db: DBConnector) -> Generator[BaseModel, None, None]:
    post = db.create_post()
    yield post
    db.delete_post(post.id)


# users

@pytest.fixture()
def users_service() -> UsersService:
    users_service = UsersService()
    return users_service


@pytest.fixture()
def create_user(users_service: UsersService) -> UserModel:
    return users_service.create_user()


@pytest.fixture()
def delete_user(
    users_service: UsersService, create_user: UserModel
) -> Generator[UserModel, None, None]:
    yield create_user
    users_service.delete_user(create_user.model.id)


@pytest.fixture()
def create_user_by_db(db: DBConnector) -> Generator[BaseModel, None, None]:
    user = db.create_user()
    yield user
    db.delete_user(user.id)