13548499350

Committed 26 Feb 2025 04:19PM UTC coverage: 80.058% (+13.0%) from 67.099%

Build # 13548499350

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #48 from SE25GroupProject/Pylint

Starting Lint

Run Details

1381 of 1725 relevant lines covered (80.06%)

0.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.97

api/tests/test_posts_api.py

from fastapi.testclient import TestClient
import pytest
from os import remove
from api.db_middleware import DBConnectionMiddleware
from api.db.convert_json_to_sql import insert_data
import tempfile

from api.main import app

client = TestClient(app)

MAIN_DB = "cookbook.db"
TEST_DB = "tests/test_cookbook.db"


@pytest.fixture(scope="module", autouse=True)
def setup_db_and_middleware():
    """Sets up a temporary database and middleware once for all tests."""
    temp_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")
    temp_db_path = temp_db.name
    temp_db.close()
    insert_data(temp_db_path, "tests/recipeTest.json")

    app.user_middleware = []
    app.add_middleware(DBConnectionMiddleware, db_path=temp_db_path)
    yield
    remove(temp_db_path)

# @pytest.fixture(scope="function", autouse=True)
# def setup_db():
#     """Copies the db to a testing db before each test"""
#     if path.exists(TEST_DB):
#         remove(TEST_DB)
#     insert_data(TEST_DB, "tests/recipeTest.json")
#     yield
#     remove(TEST_DB)

#     # Reset and add middleware once
#     app.user_middleware = []
#     app.add_middleware(DBConnectionMiddleware, db_path=temp_db_path)

#     yield

#     # Cleanup after all tests
#     remove(temp_db_path)


@pytest.fixture(scope="module")
def test_user_id():
    """Fixture to create a test user and return its ID."""
    signup_data = {"username": "testuser", "password": "testpass"}
    print("Attempting signup at: /user/signup")
    signup_response = client.post("/user/signup", json=signup_data)
    print(
        "Signup response: "
        f"{signup_response.status_code} - {signup_response.text}")
    if signup_response.status_code == 400:  # User already exists
        login_response = client.post("/user/login", json=signup_data)
        assert login_response.status_code == 200, "Login failed: "
        f"{login_response.text}"
        return login_response.json()["id"]
    assert signup_response.status_code == 200, "Signup failed: "
    f"{signup_response.text}"
    return signup_response.json()["id"]


@pytest.fixture(scope="module")
def test_post_id(test_user_id):
    """Fixture to create a test post and return its ID."""
    data = {"userId": test_user_id,
            "message": "Test post for pytest", "image": None}
    response = client.post("/posts/", json=data)
    assert response.status_code == 201, f"Create post failed: {response.text}"
    posts = client.get("/posts/").json()
    post = next(
        (p for p in posts if p["message"] == "Test post for pytest"), None)
    assert post is not None, "Test post not found"
    return post["postId"]


def test_list_posts_empty():
    """Test retrieving all posts when database is initially empty."""
    response = client.get("/posts/")
    assert response.status_code == 200, "Expected 200, "
    f"got {response.status_code}: {response.text}"
    posts = response.json()
    assert isinstance(posts, list)


def test_create_post(test_user_id):
    """Test creating a new post."""
    data = {
        "userId": test_user_id,
        "message": "New test post",
        "image": "base64testdata",
    }
    response = client.post("/posts/", json=data)
    assert response.status_code == 201, f"Create post failed: {response.text}"
    assert response.json()["message"] == "Post created successfully."


def test_get_post(test_post_id):
    """Test retrieving a post by ID."""
    response = client.get(f"/posts/{test_post_id}")
    assert response.status_code == 200
    post = response.json()
    assert post["postId"] == test_post_id
    assert "message" in post


def test_list_posts(test_post_id):
    """Test retrieving all posts after creating one."""
    response = client.get("/posts/")
    assert response.status_code == 200
    posts = response.json()
    assert isinstance(posts, list)
    assert any(p["postId"] == test_post_id for p in posts)


def test_list_posts_by_user(test_user_id, test_post_id):
    """Test retrieving posts by user ID."""
    response = client.get(f"/posts/user/{test_user_id}")
    assert response.status_code == 200
    posts = response.json()
    assert isinstance(posts, list)
    assert all(post["userId"] == test_user_id for post in posts)


def test_like_post(test_post_id, test_user_id):
    """Test liking a post."""
    response = client.put(f"/posts/like/{test_post_id}", json=test_user_id)
    assert response.status_code == 200, "Expected 200, "
    f"got {response.status_code}: {response.text}"
    assert response.json()["message"] in [
        "Post liked successfully.",
        "Changed from dislike to like successfully."]
    post = client.get(f"/posts/{test_post_id}").json()
    assert test_user_id in post["likes"]


def test_dislike_post(test_post_id, test_user_id):
    """Test disliking a post."""
    response = client.put(f"/posts/dislike/{test_post_id}", json=test_user_id)
    assert response.status_code == 200
    assert response.json()["message"] in [
        "Post disliked successfully.",
        "Changed from like to dislike successfully."]
    post = client.get(f"/posts/{test_post_id}").json()
    assert test_user_id in post["dislikes"]


def test_update_post(test_post_id, test_user_id):
    """Test updating a post’s message."""
    data = {
        "userId": 1,
        "message": "Updated test post"
    }
    response = client.put(f"/posts/{test_post_id}", json=data)
    assert response.status_code == 200
    updated_post = response.json()
    assert updated_post["message"] == "Updated test post"


def test_create_post_no_image(test_user_id):
    """Test creating a post with no image."""
    data = {
        "userId": test_user_id,
        "message": "Post with no image"
    }
    response = client.post("/posts/", json=data)
    assert response.status_code == 201, f"Create post failed: {response.text}"
    assert response.json()["message"] == "Post created successfully."

    response = client.get("/posts/")
    posts = response.json()
    print(posts)

    post = next(
        (p for p in posts if p["message"] == "Post with no image"), None)
    print(post)
    assert post is not None, "Post not found"
    assert post["image"] is None


def test_like_non_existent_post(test_user_id):
    """Test liking a post that doesn’t exist."""
    non_existent_post_id = 9999  # Assuming this ID doesn’t exist
    response = client.put(
        f"/posts/like/{non_existent_post_id}", json=test_user_id)
    assert response.status_code == 404, "Expected 404, "
    f"got {response.status_code}: {response.text}"
    assert "detail" in response.json()
    assert "not found" in response.json()["detail"].lower()


def test_dislike_after_like(test_post_id, test_user_id):
    """Test switching from like to dislike."""
    # First, like the post
    like_response = client.put(
        f"/posts/like/{test_post_id}", json=test_user_id)
    assert like_response.status_code == 200

    # Then, dislike it
    dislike_response = client.put(
        f"/posts/dislike/{test_post_id}", json=test_user_id)
    assert dislike_response.status_code == 200, "Expected 200, "
    f"got {dislike_response.status_code}: {dislike_response.text}"
    post = client.get(f"/posts/{test_post_id}").json()
    assert test_user_id not in post["likes"]
    assert test_user_id in post["dislikes"]


def test_get_non_existent_post():
    """Test retrieving a post that doesn’t exist."""
    non_existent_post_id = 9999  # Assuming this ID doesn’t exist
    response = client.get(f"/posts/{non_existent_post_id}")
    assert response.status_code == 404, "Expected 404, "
    f"got {response.status_code}: {response.text}"
    assert "detail" in response.json()
    assert "not found" in response.json()["detail"].lower()


def test_delete_post(test_post_id, test_user_id):
    response = client.request(
        "DELETE", f"/posts/{test_post_id}", json=test_user_id)
    print(f"Response: {response.status_code} - {response.text}")
    assert response.status_code == 200, "Expected 200, "
    f"got {response.status_code}: {response.text}"
    assert response.json()["message"] == "Post deleted successfully."

1	from fastapi.testclient import TestClient	1✔
2	import pytest	1✔
3	from os import remove	1✔
4	from api.db_middleware import DBConnectionMiddleware	1✔
5	from api.db.convert_json_to_sql import insert_data	1✔
6	import tempfile	1✔
7
8	from api.main import app	1✔
9
10	client = TestClient(app)	1✔
11
12	MAIN_DB = "cookbook.db"	1✔
13	TEST_DB = "tests/test_cookbook.db"	1✔
14
15
16	@pytest.fixture(scope="module", autouse=True)	1✔
17	def setup_db_and_middleware():	1✔
18	"""Sets up a temporary database and middleware once for all tests."""
19	temp_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")	1✔
20	temp_db_path = temp_db.name	1✔
21	temp_db.close()	1✔
22	insert_data(temp_db_path, "tests/recipeTest.json")	1✔
23
24	app.user_middleware = []	1✔
25	app.add_middleware(DBConnectionMiddleware, db_path=temp_db_path)	1✔
26	yield	1✔
27	remove(temp_db_path)	1✔
28
29	# @pytest.fixture(scope="function", autouse=True)
30	# def setup_db():
31	# """Copies the db to a testing db before each test"""
32	# if path.exists(TEST_DB):
33	# remove(TEST_DB)
34	# insert_data(TEST_DB, "tests/recipeTest.json")
35	# yield
36	# remove(TEST_DB)
37
38	# # Reset and add middleware once
39	# app.user_middleware = []
40	# app.add_middleware(DBConnectionMiddleware, db_path=temp_db_path)
41
42	# yield
43
44	# # Cleanup after all tests
45	# remove(temp_db_path)
46
47
48	@pytest.fixture(scope="module")	1✔
49	def test_user_id():	1✔
50	"""Fixture to create a test user and return its ID."""
51	signup_data = {"username": "testuser", "password": "testpass"}	1✔
52	print("Attempting signup at: /user/signup")	1✔
53	signup_response = client.post("/user/signup", json=signup_data)	1✔
54	print(	1✔
55	"Signup response: "
56	f"{signup_response.status_code} - {signup_response.text}")
57	if signup_response.status_code == 400: # User already exists	1✔
58	login_response = client.post("/user/login", json=signup_data)	×
59	assert login_response.status_code == 200, "Login failed: "	×
60	f"{login_response.text}"	×
61	return login_response.json()["id"]	×
62	assert signup_response.status_code == 200, "Signup failed: "	1✔
63	f"{signup_response.text}"	1✔
64	return signup_response.json()["id"]	1✔
65
66
67	@pytest.fixture(scope="module")	1✔
68	def test_post_id(test_user_id):	1✔
69	"""Fixture to create a test post and return its ID."""
70	data = {"userId": test_user_id,	1✔
71	"message": "Test post for pytest", "image": None}
72	response = client.post("/posts/", json=data)	1✔
73	assert response.status_code == 201, f"Create post failed: {response.text}"	1✔
74	posts = client.get("/posts/").json()	1✔
75	post = next(	1✔
76	(p for p in posts if p["message"] == "Test post for pytest"), None)
77	assert post is not None, "Test post not found"	1✔
78	return post["postId"]	1✔
79
80
81	def test_list_posts_empty():	1✔
82	"""Test retrieving all posts when database is initially empty."""
83	response = client.get("/posts/")	1✔
84	assert response.status_code == 200, "Expected 200, "	1✔
85	f"got {response.status_code}: {response.text}"	1✔
86	posts = response.json()	1✔
87	assert isinstance(posts, list)	1✔
88
89
90	def test_create_post(test_user_id):	1✔
91	"""Test creating a new post."""
92	data = {	1✔
93	"userId": test_user_id,
94	"message": "New test post",
95	"image": "base64testdata",
96	}
97	response = client.post("/posts/", json=data)	1✔
98	assert response.status_code == 201, f"Create post failed: {response.text}"	1✔
99	assert response.json()["message"] == "Post created successfully."	1✔
100
101
102	def test_get_post(test_post_id):	1✔
103	"""Test retrieving a post by ID."""
104	response = client.get(f"/posts/{test_post_id}")	1✔
105	assert response.status_code == 200	1✔
106	post = response.json()	1✔
107	assert post["postId"] == test_post_id	1✔
108	assert "message" in post	1✔
109
110
111	def test_list_posts(test_post_id):	1✔
112	"""Test retrieving all posts after creating one."""
113	response = client.get("/posts/")	1✔
114	assert response.status_code == 200	1✔
115	posts = response.json()	1✔
116	assert isinstance(posts, list)	1✔
117	assert any(p["postId"] == test_post_id for p in posts)	1✔
118
119
120	def test_list_posts_by_user(test_user_id, test_post_id):	1✔
121	"""Test retrieving posts by user ID."""
122	response = client.get(f"/posts/user/{test_user_id}")	1✔
123	assert response.status_code == 200	1✔
124	posts = response.json()	1✔
125	assert isinstance(posts, list)	1✔
126	assert all(post["userId"] == test_user_id for post in posts)	1✔
127
128
129	def test_like_post(test_post_id, test_user_id):	1✔
130	"""Test liking a post."""
131	response = client.put(f"/posts/like/{test_post_id}", json=test_user_id)	1✔
132	assert response.status_code == 200, "Expected 200, "	1✔
133	f"got {response.status_code}: {response.text}"	1✔
134	assert response.json()["message"] in [	1✔
135	"Post liked successfully.",
136	"Changed from dislike to like successfully."]
137	post = client.get(f"/posts/{test_post_id}").json()	1✔
138	assert test_user_id in post["likes"]	1✔
139
140
141	def test_dislike_post(test_post_id, test_user_id):	1✔
142	"""Test disliking a post."""
143	response = client.put(f"/posts/dislike/{test_post_id}", json=test_user_id)	1✔
144	assert response.status_code == 200	1✔
145	assert response.json()["message"] in [	1✔
146	"Post disliked successfully.",
147	"Changed from like to dislike successfully."]
148	post = client.get(f"/posts/{test_post_id}").json()	1✔
149	assert test_user_id in post["dislikes"]	1✔
150
151
152	def test_update_post(test_post_id, test_user_id):	1✔
153	"""Test updating a post’s message."""
154	data = {	1✔
155	"userId": 1,
156	"message": "Updated test post"
157	}
158	response = client.put(f"/posts/{test_post_id}", json=data)	1✔
159	assert response.status_code == 200	1✔
160	updated_post = response.json()	1✔
161	assert updated_post["message"] == "Updated test post"	1✔
162
163
164	def test_create_post_no_image(test_user_id):	1✔
165	"""Test creating a post with no image."""
166	data = {	1✔
167	"userId": test_user_id,
168	"message": "Post with no image"
169	}
170	response = client.post("/posts/", json=data)	1✔
171	assert response.status_code == 201, f"Create post failed: {response.text}"	1✔
172	assert response.json()["message"] == "Post created successfully."	1✔
173
174	response = client.get("/posts/")	1✔
175	posts = response.json()	1✔
176	print(posts)	1✔
177
178	post = next(	1✔
179	(p for p in posts if p["message"] == "Post with no image"), None)
180	print(post)	1✔
181	assert post is not None, "Post not found"	1✔
182	assert post["image"] is None	1✔
183
184
185	def test_like_non_existent_post(test_user_id):	1✔
186	"""Test liking a post that doesn’t exist."""
187	non_existent_post_id = 9999 # Assuming this ID doesn’t exist	1✔
188	response = client.put(	1✔
189	f"/posts/like/{non_existent_post_id}", json=test_user_id)
190	assert response.status_code == 404, "Expected 404, "	1✔
191	f"got {response.status_code}: {response.text}"	1✔
192	assert "detail" in response.json()	1✔
193	assert "not found" in response.json()["detail"].lower()	1✔
194
195
196	def test_dislike_after_like(test_post_id, test_user_id):	1✔
197	"""Test switching from like to dislike."""
198	# First, like the post
199	like_response = client.put(	1✔
200	f"/posts/like/{test_post_id}", json=test_user_id)
201	assert like_response.status_code == 200	1✔
202
203	# Then, dislike it
204	dislike_response = client.put(	1✔
205	f"/posts/dislike/{test_post_id}", json=test_user_id)
206	assert dislike_response.status_code == 200, "Expected 200, "	1✔
207	f"got {dislike_response.status_code}: {dislike_response.text}"	1✔
208	post = client.get(f"/posts/{test_post_id}").json()	1✔
209	assert test_user_id not in post["likes"]	1✔
210	assert test_user_id in post["dislikes"]	1✔
211
212
213	def test_get_non_existent_post():	1✔
214	"""Test retrieving a post that doesn’t exist."""
215	non_existent_post_id = 9999 # Assuming this ID doesn’t exist	1✔
216	response = client.get(f"/posts/{non_existent_post_id}")	1✔
217	assert response.status_code == 404, "Expected 404, "	1✔
218	f"got {response.status_code}: {response.text}"	1✔
219	assert "detail" in response.json()	1✔
220	assert "not found" in response.json()["detail"].lower()	1✔
221
222
223	def test_delete_post(test_post_id, test_user_id):	1✔
224	response = client.request(	1✔
225	"DELETE", f"/posts/{test_post_id}", json=test_user_id)
226	print(f"Response: {response.status_code} - {response.text}")	1✔
227	assert response.status_code == 200, "Expected 200, "	1✔
228	f"got {response.status_code}: {response.text}"	1✔
229	assert response.json()["message"] == "Post deleted successfully."	1✔

SE25GroupProject / my-cookbook / 13548499350

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous