def test_update_beatmapset_status_nom_qual_dq(test_database):
creator = User(3, name="test")
user1 = User(1, name="someone")
user2 = User(2, name="sometwo")
beatmapset = Beatmapset(1, creator=creator, allow_api=False)
event1 = Event("nominate",
from_string("2020-01-01 00:00:00"),
beatmapset,
user=user1)
event2 = Event("qualify",
from_string("2020-01-01 00:01:00"),
beatmapset,
user=user2)
event3 = Event("disqualify",
from_string("2020-01-02 00:00:00"),
beatmapset,
user=user1)
test_database.insert_event(event1)
test_database.insert_event(event2)
test_database.insert_event(event3)
retrieved_status = test_database.retrieve_beatmapset_status(
"beatmapset_id=%s ORDER BY time DESC", (beatmapset.id, ))
assert retrieved_status.status == "pending"
assert retrieved_status.nominators == []
retrieved_status = test_database.retrieve_beatmapset_status(
"beatmapset_id=%s AND time=%s",
(beatmapset.id, from_string("2020-01-01 00:01:00")))
assert retrieved_status.status == "qualified"
assert retrieved_status.nominators == [user1, user2]
def test_newspost_eq():
newspost1 = NewsPost(_id="1", title="title", preview="hello there", author=User(1, "someone"), slug="newspost-1", image_url="/image")
newspost2 = NewsPost(_id="1", title="title", preview="hello there", author=User(1, "someone"), slug="newspost-1", image_url="/image")
newspost3 = NewsPost(_id="1", title="title2", preview="hello there", author=User(1, "someone"), slug="newspost-1", image_url="/image")
assert newspost1 == newspost2
assert newspost1 != newspost3
def test_insert_retrieve_multiple_users(test_database):
user1 = User(1, name="test")
user2 = User(2, name="test")
test_database.insert_user(user1)
test_database.insert_user(user2)
retrieved_users = test_database.retrieve_users(where="name=%s",
where_values=(user1.name, ))
assert next(retrieved_users, None) == user1
assert next(retrieved_users, None) == user2
def test_insert_retrieve_discussion_and_replies(test_database):
time = datetime.utcnow()
author = User(1, name="one")
replier = User(2, name="two")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=replier,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion = Discussion(1,
beatmapset=beatmapset,
user=author,
content="ping",
tab="tab",
difficulty="diff")
problem = Event(_type="problem",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=author,
content="ping")
reply1 = Event(_type="reply",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=replier,
content="pong")
reply2 = Event(_type="reply",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=author,
content="miss")
test_database.insert_event(problem)
test_database.insert_event(reply1)
test_database.insert_event(reply2)
retrieved_problem = test_database.retrieve_event(
where="type=%s", where_values=("problem", ))
retrieved_reply1 = test_database.retrieve_event(
where="type=%s AND user_id=%s", where_values=("reply", replier.id))
retrieved_reply2 = test_database.retrieve_event(
where="type=%s AND user_id=%s", where_values=("reply", author.id))
assert retrieved_problem
assert retrieved_reply1
assert retrieved_reply2
def test_update_beatmapset_status_nom(test_database):
creator = User(3, name="test")
user = User(1, name="someone")
beatmapset = Beatmapset(1, creator=creator, allow_api=False)
event = Event("nominate",
from_string("2020-01-01 00:00:00"),
beatmapset,
user=user)
test_database.insert_event(
event) # Should call `update_beatmapset_status`.
retrieved_status = test_database.retrieve_beatmapset_status(
"beatmapset_id=%s", (beatmapset.id, ))
assert retrieved_status.status == "nominated"
assert retrieved_status.nominators == [user]
async def test_insert_retrieve_event(test_database):
time = datetime.utcnow()
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
event = Event(_type="test",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
test_database.insert_event(event)
retrieved_event = await test_database.retrieve_event("type=%s", ("test", ))
assert retrieved_event.type == event.type
assert retrieved_event.time == event.time
assert retrieved_event.beatmapset == event.beatmapset
assert retrieved_event.discussion == event.discussion
assert retrieved_event.user == event.user
assert retrieved_event.content == event.content
assert retrieved_event == event
async def test_insert_retrieve_multiple_events(test_database):
time = datetime.utcnow()
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
event1 = Event(_type="test",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
event2 = Event(_type="123",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
test_database.insert_event(event1)
test_database.insert_event(event2)
retrieved_events = test_database.retrieve_events(
where="beatmapset_id=%s", where_values=(beatmapset.id, ))
assert await anext(retrieved_events, None) == event1
assert await anext(retrieved_events, None) == event2
def test_insert_retrieve_multiple_discussions(test_database):
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion1 = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
discussion2 = Discussion(2,
beatmapset=beatmapset,
user=user,
content="real testing",
tab="tab",
difficulty="diff")
test_database.insert_discussion(discussion1)
test_database.insert_discussion(discussion2)
retrieved_discussions = test_database.retrieve_discussions(
where="beatmapset_id=%s", where_values=(beatmapset.id, ))
assert next(retrieved_discussions, None) == discussion1
assert next(retrieved_discussions, None) == discussion2
def test_insert_retrieve_discussion(test_database):
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
test_database.insert_discussion(discussion)
retrieved_discussion = test_database.retrieve_discussion(
where="id=%s", where_values=(1, ))
assert retrieved_discussion.id == discussion.id
assert retrieved_discussion.beatmapset == discussion.beatmapset
assert retrieved_discussion.user == discussion.user
assert retrieved_discussion.content == discussion.content
assert retrieved_discussion.tab == discussion.tab
assert retrieved_discussion.difficulty == discussion.difficulty
assert retrieved_discussion == discussion
async def test_insert_retrieve_multiple_events(test_database):
time = datetime.utcnow()
user = User(1, name="test")
beatmapset = Beatmapset(1, creator=user, allow_api=False)
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
event1 = Event(_type="test",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
event2 = Event(_type="123",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
test_database.insert_event(event1)
test_database.insert_event(event2)
retrieved_events = test_database.retrieve_events(
where="beatmapset_id=%s", where_values=(beatmapset.id, ))
assert await anext(retrieved_events, None) == event1
assert await anext(retrieved_events, None) == event2
async def test_insert_retrieve_event(test_database):
time = datetime.utcnow()
user = User(1, allow_api=False)
beatmapset = Beatmapset(1, creator=user, allow_api=False)
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
event = Event(_type="test",
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user)
test_database.insert_event(event)
retrieved_event = await test_database.retrieve_event("type=%s", ("test", ))
assert retrieved_event.type == event.type
assert retrieved_event.time == event.time
assert retrieved_event.beatmapset == event.beatmapset
assert retrieved_event.discussion == event.discussion
assert retrieved_event.user == event.user
assert retrieved_event.content == event.content
assert retrieved_event == event
def retrieve_newsposts(
self,
where: str,
where_values: tuple = None,
group_by: str = None,
order_by: str = None,
limit: int = None) -> Generator[NewsPost, None, None]:
"""Returns a generator of all newsposts from the database matching the given WHERE clause."""
fetched_rows = self.retrieve_table_data(
table="newsposts",
where=where,
where_values=where_values,
selection=
"id, title, preview, author_id, author_name, slug, image_url",
group_by=group_by,
order_by=order_by,
limit=limit)
for row in (fetched_rows or []):
_id = row[0]
title = row[1]
preview = row[2]
author = self.retrieve_user("id=%s", (row[3], ))
author_name = row[4]
if not author:
author = User(_id=None, name=author_name)
slug = row[5]
image_url = row[6]
yield NewsPost(_id, title, preview, author, slug, image_url)
async def test_insert_retrieve_event_digit_properties(test_database):
user = User(1, "497")
beatmapset = Beatmapset(3,
artist="5",
title="2",
creator=user,
allow_api=False)
discussion = Discussion(2,
beatmapset,
user,
content="8",
tab="tab",
difficulty="diff")
event = Event(_type="test",
time=datetime.utcnow(),
user=user,
beatmapset=beatmapset,
discussion=discussion,
content="4")
test_database.insert_event(event)
retrieved_event = await test_database.retrieve_event(
where="type=%s", where_values=("test", ))
# Ensures the database field retrieval retains the `str` type, rather than reinterpreting as `int`.
assert retrieved_event.content == "4"
assert retrieved_event.user.name == "497"
assert retrieved_event.beatmapset.artist == "5"
assert retrieved_event.beatmapset.title == "2"
assert retrieved_event.discussion.content == "8"
def test_insert_incomplete_discussion(test_database):
user = User(1, name="test")
beatmapset = Beatmapset(1, creator=user, allow_api=False)
discussion = Discussion(1, beatmapset=beatmapset)
with pytest.raises(ValueError) as error:
test_database.insert_discussion(discussion)
assert "missing from discussion" in str(error.value)
def test_newspost_hash():
newspost = NewsPost(_id="1",
title="title",
preview="hello there",
author=User(1, "someone"),
slug="newspost-1",
image_url="/image")
assert hash(newspost)
def test_newspost_eq_different_types():
newspost = NewsPost(_id="1",
title="title",
preview="hello there",
author=User(1, "someone"),
slug="newspost-1",
image_url="/image")
assert newspost != "string"
def parse_event_json(self,
event_json: object,
user_jsons: object = None) -> Event:
"""Returns a BeatmapsetEvent reflecting the given event json object.
Ignores any event with an incomplete context (e.g. deleted beatmaps).
Requests user names from the api unless supplied with the corresponding user json from the discussion page."""
if not event_json:
# Seems to occur when the respective beatmapset has been deleted. However, it's there when
# viewing the page source manually for some reason, regardless of login status.
log_err(
"WARNING | An event is missing; the beatmapset was probably deleted."
)
return None
try:
# Scrape object data
_type = event_json["message_type"]
time = timestamp.from_string(event_json["created_at"])
beatmapset_id = event_json["beatmapset_id"]
discussion_id = event_json["starting_post"][
"beatmap_discussion_id"]
user_id = event_json["user_id"]
# The user name is either provided by a user json from the discussion page, or queried through the api.
user_json = self.__lookup_user_json(user_id, user_jsons)
user_name = user_json["username"] if user_json else None
content = event_json["starting_post"]["message"]
difficulty = event_json["beatmap"][
"version"] if "beatmap" in event_json and "version" in event_json[
"beatmap"] else None
tab = None
if event_json["timestamp"] is not None: tab = "timeline"
elif difficulty: tab = "general"
else: tab = "generalAll"
# Reconstruct objects
beatmapset = Beatmapset(beatmapset_id)
user = User(user_id, user_name) if user_id is not None else None
# TODO: This portion is missing handling for replies, see the other method.
# Still unclear which message_type replies use; will need to find out if/when replies get json formats.
discussion = Discussion(
discussion_id, beatmapset, user, content, tab,
difficulty) if discussion_id is not None else None
except DeletedContextError as err:
log_err(err)
else:
return Event(_type=_type,
time=time,
beatmapset=beatmapset,
discussion=discussion,
user=user,
content=content)
return None
def test_insert_retrieve_user(test_database):
user = User(1, name="test")
test_database.insert_user(user)
retrieved_user = test_database.retrieve_user(where="id=%s",
where_values=(1, ))
assert retrieved_user.id == user.id
assert retrieved_user.name == user.name
assert retrieved_user == user
def test_insert_retrieve_multiple_group_users(test_database):
user = User(1, name="test")
test_database.insert_group_user(group=Usergroup(4), user=user)
test_database.insert_group_user(group=Usergroup(4),
user=User(2, name="test2"))
test_database.insert_group_user(group=Usergroup(7), user=user)
retrieved_group_user_relations = test_database.retrieve_group_users(
where="user_id=%s", where_values=(1, ))
retrieved_groups = []
retrieved_users = []
for retrieved_group, retrieved_user in retrieved_group_user_relations:
retrieved_groups.append(retrieved_group)
retrieved_users.append(retrieved_user)
assert Usergroup(4) in retrieved_groups
assert Usergroup(7) in retrieved_groups
assert retrieved_users == [user, user]
def test_newspost():
newspost = NewsPost(_id=1, title="title", preview="hello there", author=User(1, "someone"), slug="newspost-1", image_url="/image")
assert newspost.id == 1
assert newspost.title == "title"
assert newspost.preview == "hello there"
assert newspost.author.id == 1
assert newspost.author.name == "someone"
assert newspost.slug == "newspost-1"
assert newspost.image_url == "/image"
def test_insert_retrieve_beatmapset_status(test_database):
creator = User(3, name="test")
user1 = User(1, name="someone")
user2 = User(2, name="sometwo")
beatmapset = Beatmapset(1, creator=creator, allow_api=False)
status = BeatmapsetStatus(_id=1,
beatmapset=beatmapset,
status="qualified",
time=from_string("2020-01-01 00:00:00"),
nominators=[user1, user2])
test_database.insert_beatmapset_status(status)
retrieved_status = test_database.retrieve_beatmapset_status(
"beatmapset_id=%s", (beatmapset.id, ))
assert retrieved_status.beatmapset == status.beatmapset
assert retrieved_status.status == status.status
assert retrieved_status.time == status.time
assert retrieved_status.nominators == status.nominators
assert retrieved_status == status
async def test_insert_retrieve_event_group_change_hybrid(test_database):
event_old = Event(_type="add",
time=from_string("2020-01-01 00:00:00"),
user=User(2, name="sometwo"),
group=Usergroup(7, mode="osu"))
event = Event(_type="add",
time=datetime.utcnow(),
user=User(2, name="sometwo"),
group=Usergroup(7, mode="taiko"))
test_database.insert_event(event_old)
test_database.insert_event(event)
retrieved_event = await test_database.retrieve_event("type=%s", ("add", ),
order_by="time DESC")
assert retrieved_event.type == event.type
assert retrieved_event.time == event.time
assert retrieved_event.group == event.group
assert retrieved_event.group.mode == event.group.mode
assert retrieved_event.user == event.user
assert retrieved_event == event
def retrieve_users(
self,
where: str,
where_values: tuple = None) -> Generator[User, None, None]:
"""Returns a generator of all users from the database matching the given WHERE clause."""
fetched_rows = self.retrieve_table_data(table="users",
where=where,
where_values=where_values,
selection="id, name")
for row in (fetched_rows or []):
_id = row[0]
name = row[1]
yield User(_id, name)
def test_insert_retrieve_beatmapset_modes(test_database):
modes = ["osu", "taiko"]
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=modes,
genre="genre",
language="language")
test_database.insert_beatmapset_modes(beatmapset)
retrieved_modes = test_database.retrieve_beatmapset_modes(1)
assert retrieved_modes == modes
def test_insert_retrieve_obv_sev(test_database):
user = User(1, name="test")
beatmapset = Beatmapset(1, creator=user, allow_api=False)
discussion = Discussion(1,
beatmapset=beatmapset,
user=user,
content="testing",
tab="tab",
difficulty="diff")
test_database.insert_obv_sev(discussion, obv=2, sev=0)
obv, sev = test_database.retrieve_obv_sev(discussion_id=1)
assert obv == 2
assert sev == 0
def test_insert_incomplete_discussion(test_database):
user = User(1, name="test")
beatmapset = Beatmapset(1,
artist="123",
title="456",
creator=user,
modes=["osu", "taiko"],
genre="genre",
language="language")
discussion = Discussion(1, beatmapset=beatmapset)
with pytest.raises(ValueError) as error:
test_database.insert_discussion(discussion)
assert "missing from discussion" in str(error.value)
async def test_insert_retrieve_event_group_change(test_database):
event = Event(_type="add",
time=datetime.utcnow(),
user=User(2, name="sometwo"),
group=Usergroup(7, mode="osu"))
test_database.insert_event(event)
retrieved_event = await test_database.retrieve_event("type=%s", ("add", ))
assert retrieved_event.type == event.type
assert retrieved_event.time == event.time
assert retrieved_event.group == event.group
assert retrieved_event.group.mode == event.group.mode
assert retrieved_event.user == event.user
assert retrieved_event == event
def parse_post_json(post_json: object) -> Event:
"""Returns an event representing the given news post json object
(a single news post instance, for multiple see `parse_post_jsons`)."""
author = User(name=post_json["author"].strip())
return Event(_type="news",
time=from_string(post_json["published_at"]),
newspost=NewsPost(_id=post_json["id"],
title=post_json["title"],
preview=post_json["preview"],
author=author,
slug=post_json["slug"],
image_url=complete_image_url(
post_json["first_image"])),
user=author if author.id else None,
content=post_json["preview"])
def test_insert_retrieve_delete_group_user(test_database):
user = User(1, name="test")
test_database.insert_group_user(group=Usergroup(4), user=user)
retrieved_group, retrieved_user = test_database.retrieve_group_user(
where="group_id=%s AND user_id=%s", where_values=(4, 1))
assert retrieved_group.id == 4
assert retrieved_group.name == "Global Moderation Team"
assert retrieved_group.mode is None
assert retrieved_user.id == 1
assert retrieved_user.name == "test"
test_database.delete_group_user(group=Usergroup(4), user=user)
retrieved_group_user_relation = test_database.retrieve_group_user(
where="group_id=%s AND user_id=%s", where_values=(4, 1))
assert retrieved_group_user_relation is None
def retrieve_users(self,
where: str,
where_values: tuple = None,
group_by: str = None,
order_by: str = None,
limit: int = None) -> Generator[User, None, None]:
"""Returns a generator of all users from the database matching the given WHERE clause."""
fetched_rows = self.retrieve_table_data(table="users",
where=where,
where_values=where_values,
selection="id, name",
group_by=group_by,
order_by=order_by,
limit=limit)
for row in (fetched_rows or []):
_id = row[0]
name = row[1]
yield User(_id, name, allow_api=False)