View: backend/tests/api/routes/test_items.py — full-stack-fastapi-template

1

import uuid

2

3

from fastapi.testclient import TestClient

4

from sqlmodel import Session

5

6

from app.core.config import settings

7

from tests.utils.item import create_random_item

8

9

10

def test_create_item(

11

    client: TestClient, superuser_token_headers: dict[str, str]

12

) -> None:

13

    data = {"title": "Foo", "description": "Fighters"}

14

    response = client.post(

15

        f"{settings.API_V1_STR}/items/",

16

        headers=superuser_token_headers,

17

        json=data,

18

19

    assert response.status_code == 200

20

    content = response.json()

21

    assert content["title"] == data["title"]

22

    assert content["description"] == data["description"]

23

    assert "id" in content

24

    assert "owner_id" in content

25

26

27

def test_read_item(

28

    client: TestClient, superuser_token_headers: dict[str, str], db: Session

29

) -> None:

30

    item = create_random_item(db)

31

    response = client.get(

32

        f"{settings.API_V1_STR}/items/{item.id}",

33

        headers=superuser_token_headers,

34

35

    assert response.status_code == 200

36

    content = response.json()

37

    assert content["title"] == item.title

38

    assert content["description"] == item.description

39

    assert content["id"] == str(item.id)

40

    assert content["owner_id"] == str(item.owner_id)

41

42

43

def test_read_item_not_found(

44

    client: TestClient, superuser_token_headers: dict[str, str]

45

) -> None:

46

    response = client.get(

47

        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",

48

        headers=superuser_token_headers,

49

50

    assert response.status_code == 404

51

    content = response.json()

52

    assert content["detail"] == "Item not found"

53

54

55

def test_read_item_not_enough_permissions(

56

    client: TestClient, normal_user_token_headers: dict[str, str], db: Session

57

) -> None:

58

    item = create_random_item(db)

59

    response = client.get(

60

        f"{settings.API_V1_STR}/items/{item.id}",

61

        headers=normal_user_token_headers,

62

63

    assert response.status_code == 403

64

    content = response.json()

65

    assert content["detail"] == "Not enough permissions"

66

67

68

def test_read_items(

69

    client: TestClient, superuser_token_headers: dict[str, str], db: Session

70

) -> None:

71

    create_random_item(db)

72

    create_random_item(db)

73

    response = client.get(

74

        f"{settings.API_V1_STR}/items/",

75

        headers=superuser_token_headers,

76

77

    assert response.status_code == 200

78

    content = response.json()

79

    assert len(content["data"]) >= 2

80

81

82

def test_update_item(

83

    client: TestClient, superuser_token_headers: dict[str, str], db: Session

84

) -> None:

85

    item = create_random_item(db)

86

    data = {"title": "Updated title", "description": "Updated description"}

87

    response = client.put(

88

        f"{settings.API_V1_STR}/items/{item.id}",

89

        headers=superuser_token_headers,

90

        json=data,

91

92

    assert response.status_code == 200

93

    content = response.json()

94

    assert content["title"] == data["title"]

95

    assert content["description"] == data["description"]

96

    assert content["id"] == str(item.id)

97

    assert content["owner_id"] == str(item.owner_id)

98

99

100

def test_update_item_not_found(

101

    client: TestClient, superuser_token_headers: dict[str, str]

102

) -> None:

103

    data = {"title": "Updated title", "description": "Updated description"}

104

    response = client.put(

105

        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",

106

        headers=superuser_token_headers,

107

        json=data,

108

109

    assert response.status_code == 404

110

    content = response.json()

111

    assert content["detail"] == "Item not found"

112

113

114

def test_update_item_not_enough_permissions(

115

    client: TestClient, normal_user_token_headers: dict[str, str], db: Session

116

) -> None:

117

    item = create_random_item(db)

118

    data = {"title": "Updated title", "description": "Updated description"}

119

    response = client.put(

120

        f"{settings.API_V1_STR}/items/{item.id}",

121

        headers=normal_user_token_headers,

122

        json=data,

123

124

    assert response.status_code == 403

125

    content = response.json()

126

    assert content["detail"] == "Not enough permissions"

127

128

129

def test_delete_item(

130

    client: TestClient, superuser_token_headers: dict[str, str], db: Session

131

) -> None:

132

    item = create_random_item(db)

133

    response = client.delete(

134

        f"{settings.API_V1_STR}/items/{item.id}",

135

        headers=superuser_token_headers,

136

137

    assert response.status_code == 200

138

    content = response.json()

139

    assert content["message"] == "Item deleted successfully"

140

141

142

def test_delete_item_not_found(

143

    client: TestClient, superuser_token_headers: dict[str, str]

144

) -> None:

145

    response = client.delete(

146

        f"{settings.API_V1_STR}/items/{uuid.uuid4()}",

147

        headers=superuser_token_headers,

148

149

    assert response.status_code == 404

150

    content = response.json()

151

    assert content["detail"] == "Item not found"

152

153

154

def test_delete_item_not_enough_permissions(

155

    client: TestClient, normal_user_token_headers: dict[str, str], db: Session

156

) -> None:

157

    item = create_random_item(db)

158

    response = client.delete(

159

        f"{settings.API_V1_STR}/items/{item.id}",

160

        headers=normal_user_token_headers,

161

162

    assert response.status_code == 403

163

    content = response.json()

164

    assert content["detail"] == "Not enough permissions"

165

1	import uuid
2
3	from fastapi.testclient import TestClient
4	from sqlmodel import Session
5
6	from app.core.config import settings
7	from tests.utils.item import create_random_item
8
9
10	def test_create_item(
11	client: TestClient, superuser_token_headers: dict[str, str]
12	) -> None:
13	data = {"title": "Foo", "description": "Fighters"}
14	response = client.post(
15	f"{settings.API_V1_STR}/items/",
16	headers=superuser_token_headers,
17	json=data,
18	)
19	assert response.status_code == 200
20	content = response.json()
21	assert content["title"] == data["title"]
22	assert content["description"] == data["description"]
23	assert "id" in content
24	assert "owner_id" in content
25
26
27	def test_read_item(
28	client: TestClient, superuser_token_headers: dict[str, str], db: Session
29	) -> None:
30	item = create_random_item(db)
31	response = client.get(
32	f"{settings.API_V1_STR}/items/{item.id}",
33	headers=superuser_token_headers,
34	)
35	assert response.status_code == 200
36	content = response.json()
37	assert content["title"] == item.title
38	assert content["description"] == item.description
39	assert content["id"] == str(item.id)
40	assert content["owner_id"] == str(item.owner_id)
41
42
43	def test_read_item_not_found(
44	client: TestClient, superuser_token_headers: dict[str, str]
45	) -> None:
46	response = client.get(
47	f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
48	headers=superuser_token_headers,
49	)
50	assert response.status_code == 404
51	content = response.json()
52	assert content["detail"] == "Item not found"
53
54
55	def test_read_item_not_enough_permissions(
56	client: TestClient, normal_user_token_headers: dict[str, str], db: Session
57	) -> None:
58	item = create_random_item(db)
59	response = client.get(
60	f"{settings.API_V1_STR}/items/{item.id}",
61	headers=normal_user_token_headers,
62	)
63	assert response.status_code == 403
64	content = response.json()
65	assert content["detail"] == "Not enough permissions"
66
67
68	def test_read_items(
69	client: TestClient, superuser_token_headers: dict[str, str], db: Session
70	) -> None:
71	create_random_item(db)
72	create_random_item(db)
73	response = client.get(
74	f"{settings.API_V1_STR}/items/",
75	headers=superuser_token_headers,
76	)
77	assert response.status_code == 200
78	content = response.json()
79	assert len(content["data"]) >= 2
80
81
82	def test_update_item(
83	client: TestClient, superuser_token_headers: dict[str, str], db: Session
84	) -> None:
85	item = create_random_item(db)
86	data = {"title": "Updated title", "description": "Updated description"}
87	response = client.put(
88	f"{settings.API_V1_STR}/items/{item.id}",
89	headers=superuser_token_headers,
90	json=data,
91	)
92	assert response.status_code == 200
93	content = response.json()
94	assert content["title"] == data["title"]
95	assert content["description"] == data["description"]
96	assert content["id"] == str(item.id)
97	assert content["owner_id"] == str(item.owner_id)
98
99
100	def test_update_item_not_found(
101	client: TestClient, superuser_token_headers: dict[str, str]
102	) -> None:
103	data = {"title": "Updated title", "description": "Updated description"}
104	response = client.put(
105	f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
106	headers=superuser_token_headers,
107	json=data,
108	)
109	assert response.status_code == 404
110	content = response.json()
111	assert content["detail"] == "Item not found"
112
113
114	def test_update_item_not_enough_permissions(
115	client: TestClient, normal_user_token_headers: dict[str, str], db: Session
116	) -> None:
117	item = create_random_item(db)
118	data = {"title": "Updated title", "description": "Updated description"}
119	response = client.put(
120	f"{settings.API_V1_STR}/items/{item.id}",
121	headers=normal_user_token_headers,
122	json=data,
123	)
124	assert response.status_code == 403
125	content = response.json()
126	assert content["detail"] == "Not enough permissions"
127
128
129	def test_delete_item(
130	client: TestClient, superuser_token_headers: dict[str, str], db: Session
131	) -> None:
132	item = create_random_item(db)
133	response = client.delete(
134	f"{settings.API_V1_STR}/items/{item.id}",
135	headers=superuser_token_headers,
136	)
137	assert response.status_code == 200
138	content = response.json()
139	assert content["message"] == "Item deleted successfully"
140
141
142	def test_delete_item_not_found(
143	client: TestClient, superuser_token_headers: dict[str, str]
144	) -> None:
145	response = client.delete(
146	f"{settings.API_V1_STR}/items/{uuid.uuid4()}",
147	headers=superuser_token_headers,
148	)
149	assert response.status_code == 404
150	content = response.json()
151	assert content["detail"] == "Item not found"
152
153
154	def test_delete_item_not_enough_permissions(
155	client: TestClient, normal_user_token_headers: dict[str, str], db: Session
156	) -> None:
157	item = create_random_item(db)
158	response = client.delete(
159	f"{settings.API_V1_STR}/items/{item.id}",
160	headers=normal_user_token_headers,
161	)
162	assert response.status_code == 403
163	content = response.json()
164	assert content["detail"] == "Not enough permissions"
165