Coverage for app/tests/api/routes/test_items.py: 100%

1import uuid 

2 

3from fastapi.testclient import TestClient 

4from sqlmodel import Session 

5 

6from app.core.config import settings 

7from app.tests.utils.item import create_random_item 

8 

9 

10def 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 

27def 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 

43def 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 

55def 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 == 400 

64 content = response.json() 

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

66 

67 

68def 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 

82def 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 

100def 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 

114def 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 == 400 

125 content = response.json() 

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

127 

128 

129def 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 

142def 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 

154def 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 == 400 

163 content = response.json() 

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