def test_for_community_if_sender_not_member(self, community):
MessageFactory(
sender=MembershipFactory(community=CommunityFactory(),
active=True).member,
recipient=MembershipFactory(community=community).member,
)
assert not Message.objects.for_community(community).exists()
def test_notify_on_create_if_no_content_object(self, community):
comment_owner = MembershipFactory(community=community).member
post_owner = MembershipFactory(
community=community,
).member
mentioned = UserFactory(username="******")
MembershipFactory(member=mentioned, community=community)
post = PostFactory(
owner=post_owner, community=community, deleted=timezone.now()
)
CommentFactory(
owner=MembershipFactory(community=community).member,
content_object=post,
)
comment = CommentFactory(
owner=comment_owner,
community=community,
content_object=post,
content="hello @danjac",
)
follower = MembershipFactory(community=community).member
follower.following.add(comment.owner)
notifications = list(comment.notify_on_create())
assert len(notifications) == 0
def test_notify_on_update_moderator_edit(self, community, send_webpush_mock):
owner = MembershipFactory(community=community).member
member = MembershipFactory(
community=community,
member=UserFactory(username="******"),
).member
moderator = MembershipFactory(
community=community,
).member
post = PostFactory(
owner=owner,
community=community,
description="hello from @owner #movies #reviews",
)
post.description = "hello @danjac"
post.editor = moderator
post.save()
notifications = post.notify_on_update()
assert len(notifications) == 2
assert notifications[0].recipient == member
assert notifications[0].actor == post.owner
assert notifications[0].verb == "mention"
assert notifications[1].recipient == post.owner
assert notifications[1].actor == moderator
assert notifications[1].verb == "edit"
def test_authenticated(self, member):
other = MembershipFactory(member=member.member).community
post = PostFactory(
community=other, owner=MembershipFactory(community=other).member
)
Notification.objects.create(
content_object=post,
recipient=member.member,
actor=post.owner,
community=post.community,
verb="updated",
is_read=False,
)
Notification.objects.create(
content_object=post,
recipient=member.member,
actor=post.owner,
community=post.community,
verb="updated",
is_read=True,
)
assert (
get_unread_external_notification_count(member.member, member.community) == 1
)
def test_member_cache(self):
user = UserFactory()
first = MembershipFactory(member=user,
role=Membership.Role.ADMIN,
active=True).community
second = MembershipFactory(member=user,
role=Membership.Role.MODERATOR,
active=True).community
third = MembershipFactory(member=user,
role=Membership.Role.MEMBER,
active=True).community
fourth = MembershipFactory(member=user,
role=Membership.Role.MEMBER,
active=False).community
fifth = CommunityFactory()
assert user.member_cache.has_role(first.id, [Membership.Role.ADMIN])
assert user.member_cache.has_role(second.id,
[Membership.Role.MODERATOR])
assert user.member_cache.has_role(third.id, [Membership.Role.MEMBER])
assert user.member_cache.has_role(first.id)
assert user.member_cache.has_role(second.id)
assert user.member_cache.has_role(third.id)
assert not user.member_cache.has_role(fourth.id)
assert not user.member_cache.has_role(fifth.id)
assert not user.member_cache.is_inactive(first.id)
assert not user.member_cache.is_inactive(second.id)
assert not user.member_cache.is_inactive(third.id)
assert not user.member_cache.is_inactive(fifth.id)
assert user.member_cache.is_inactive(fourth.id)
def test_notify_on_update(self, community, mailoutbox, send_webpush_mock):
comment_owner = MembershipFactory(
community=community,
).member
member = MembershipFactory(
community=community, member=UserFactory(username="******")
).member
post_owner = MembershipFactory(community=community).member
post = PostFactory(owner=post_owner, community=community)
comment = CommentFactory(
owner=comment_owner,
community=community,
content_object=post,
content="hello",
)
comment.content = "hello @danjac"
comment.save()
notifications = list(comment.notify_on_update())
assert len(notifications) == 1
assert notifications[0].recipient == member
assert notifications[0].actor == comment_owner
assert notifications[0].verb == "mention"
def test_get_if_neither_recipient_nor_sender(self, client, member):
sender = MembershipFactory(community=member.community).member
recipient = MembershipFactory(community=member.community).member
message = MessageFactory(community=member.community,
sender=sender,
recipient=recipient)
response = client.get(message.get_absolute_url())
assert response.status_code == http.HTTPStatus.NOT_FOUND
def test_authenticated(self, member):
other = MembershipFactory(member=member.member).community
MessageFactory(
community=other,
recipient=member.member,
sender=MembershipFactory(community=other).member,
)
assert get_unread_external_message_count(member.member,
member.community) == 1
def test_for_community(self, community):
comment = CommentFactory(
community=community,
owner=MembershipFactory(community=community).member,
)
CommentFactory(owner=MembershipFactory(community=community).member)
CommentFactory(community=community)
CommentFactory()
assert Comment.objects.for_community(community).get() == comment
def test_notify_on_publish(self, community, send_webpush_mock):
# owner should not receive any notifications from their own posts
owner = MembershipFactory(
community=community, role=Membership.Role.MODERATOR
).member
mentioned = MembershipFactory(
member=UserFactory(username="******"),
community=community,
role=Membership.Role.MEMBER,
).member
# ensure we just have one notification for multiple tags
movies = Tag.objects.create(name="movies")
reviews = Tag.objects.create(name="reviews")
post = PostFactory(
owner=owner,
community=community,
description="hello @danjac from @owner #movies #reviews",
)
tag_follower = MembershipFactory(
community=community,
member=UserFactory(),
).member
tag_follower.following_tags.add(movies, reviews)
# owner should also follow tags to ensure they aren't notified
owner.following_tags.add(movies, reviews)
assert tag_follower.following_tags.count() == 2
user_follower = MembershipFactory(
community=community,
member=UserFactory(),
).member
user_follower.following.add(post.owner)
notifications = post.notify_on_publish()
assert len(notifications) == 3
assert notifications[0].recipient == mentioned
assert notifications[0].actor == post.owner
assert notifications[0].verb == "mention"
assert notifications[1].recipient == tag_follower
assert notifications[1].actor == post.owner
assert notifications[1].verb == "followed_tag"
assert notifications[2].recipient == user_follower
assert notifications[2].actor == post.owner
assert notifications[2].verb == "followed_user"
def test_for_community(self, community):
message = MessageFactory(
community=community,
sender=MembershipFactory(community=community).member,
recipient=MembershipFactory(community=community).member,
)
qs = Message.objects.for_community(community)
assert qs.count() == 1
assert qs.first() == message
def test_notify_on_follow(self, member, send_webpush_mock):
follower = MembershipFactory(
community=member.community,
member=UserFactory(),
).member
notifications = follower.notify_on_follow(member.member,
member.community)
assert len(notifications) == 1
assert notifications[0].recipient == member.member
assert notifications[0].content_object == follower
assert notifications[0].actor == follower
assert notifications[0].community == member.community
assert notifications[0].verb == "new_follower"
assert send_webpush_mock.is_called()
def test_get(self, client, member, user):
other = MembershipFactory(
community=member.community, member=UserFactory(name="tester")
).member
blocker = MembershipFactory(
community=member.community, member=UserFactory(name="tester")
).member
blocker.blocked.add(member.member)
response = client.get(reverse("users:autocomplete_list"), {"q": "tester"})
object_list = response.context["users"]
assert other in object_list
assert blocker not in object_list
def test_get_count_if_not_admin(self, member):
membership = MembershipFactory(role=Membership.Role.MEMBER,
member=member.member)
JoinRequestFactory(community=membership.community)
count = get_pending_external_join_request_count(
member.member, member.community)
assert count == 0
def test_get_if_anonymous(self, client, community):
user = MembershipFactory(community=community).member
response = client.get(reverse("users:member_list"))
assert response.status_code == http.HTTPStatus.OK
object_list = response.context["object_list"]
assert user in object_list
def test_get(self, client, member):
post = PostFactory(
community=member.community,
owner=MembershipFactory(community=member.community).member,
)
response = client.get(reverse("posts:flag", args=[post.id]))
assert response.status_code == http.HTTPStatus.OK
def handle(self, *args, **options):
num_users = options["num_users"]
domain = options["domain"]
try:
community = Community.objects.get(domain__iexact=domain)
except Community.DoesNotExist:
raise CommandError(f"No community found for {domain}")
if (input(
f"This will create {num_users} new users for community {community.name}. Do you wish to continue ? (Y/n) "
).lower() != "y"):
return
password = getpass.getpass(
"Password (leave empty for randomized password): ").strip()
num_created = 0
for _ in range(num_users):
try:
membership = MembershipFactory(community=community)
if password:
membership.member.set_password(password)
membership.member.save()
num_created += 1
self.stdout.write(" | ".join(
(membership.member.username, membership.member.email)))
except IntegrityError:
...
self.stdout.write(
self.style.SUCCESS(f"{num_created} new users created"))
def test_get(self, client, member):
sender = MembershipFactory(community=member.community).member
MessageFactory(community=member.community,
recipient=member.member,
sender=sender)
response = client.get(reverse("private_messages:inbox"))
assert len(response.context["object_list"]) == 1
def test_notify_on_publish_reshare(self, community, send_webpush_mock):
mentioned = MembershipFactory(
member=UserFactory(username="******"),
community=community,
role=Membership.Role.MEMBER,
).member
# ensure we just have one notification for multiple tags
movies = Tag.objects.create(name="movies")
reviews = Tag.objects.create(name="reviews")
tag_follower = MembershipFactory(
community=community,
member=UserFactory(),
).member
tag_follower.following_tags.add(movies, reviews)
assert tag_follower.following_tags.count() == 2
owner = MembershipFactory(
community=community,
).member
post = PostFactory(
owner=owner,
community=community,
description="hello @danjac from @owner #movies #reviews",
)
# reshare
reshare = post.reshare(UserFactory())
notifications = list(reshare.notify_on_publish())
assert len(notifications) == 3
assert notifications[0].recipient == post.owner
assert notifications[0].actor == reshare.owner
assert notifications[0].verb == "reshare"
assert notifications[1].recipient == mentioned
assert notifications[1].actor == reshare.owner
assert notifications[1].verb == "mention"
assert notifications[2].recipient == tag_follower
assert notifications[2].actor == reshare.owner
assert notifications[2].verb == "followed_tag"
def test_notify_on_create(self, community, mailoutbox, send_webpush_mock):
comment_owner = MembershipFactory(community=community).member
post_owner = MembershipFactory(
community=community,
).member
mentioned = UserFactory(username="******")
MembershipFactory(member=mentioned, community=community)
post = PostFactory(owner=post_owner, community=community)
other_comment = CommentFactory(
owner=MembershipFactory(community=community).member,
content_object=post,
)
comment = CommentFactory(
owner=comment_owner,
community=community,
content_object=post,
content="hello @danjac",
)
follower = MembershipFactory(community=community).member
follower.following.add(comment.owner)
notifications = list(comment.notify_on_create())
assert len(notifications) == 4
assert notifications[0].recipient == mentioned
assert notifications[0].actor == comment.owner
assert notifications[0].verb == "mention"
assert notifications[1].recipient == post.owner
assert notifications[1].actor == comment.owner
assert notifications[1].verb == "new_comment"
assert notifications[2].recipient == other_comment.owner
assert notifications[2].actor == comment.owner
assert notifications[2].verb == "new_sibling"
assert notifications[3].recipient == follower
assert notifications[3].actor == comment.owner
assert notifications[3].verb == "followed_user"
def test_for_community(self, community: Community):
post = PostFactory(
community=community,
owner=MembershipFactory(community=community).member,
)
PostFactory(owner=MembershipFactory(community=community).member)
PostFactory(owner=MembershipFactory(community=community, active=False).member)
PostFactory(
owner=MembershipFactory(community=CommunityFactory(), active=True).member
)
PostFactory(community=community)
PostFactory()
qs = Post.objects.for_community(community)
assert qs.count() == 1
assert qs.first() == post
def notification(post):
return NotificationFactory(
recipient=MembershipFactory(community=post.community).member,
community=post.community,
actor=post.owner,
content_object=post,
verb="mention",
)
def test_get(self, client, member):
sender = MembershipFactory(community=member.community).member
parent = MessageFactory(sender=sender,
recipient=member.member,
community=member.community)
response = client.get(
reverse("private_messages:message_reply", args=[parent.id]))
assert response.status_code == http.HTTPStatus.OK
def test_get(self, client, member):
PostFactory(
community=member.community,
owner=MembershipFactory(community=member.community).member,
).tags.add("movies")
response = client.get(reverse("hashtags:detail", args=["movies"]))
assert response.context["tag"].name == "movies"
assert len(response.context["object_list"]) == 1
def test_get_count_if_not_moderator(self, member):
other = MembershipFactory(member=member.member)
post = PostFactory(community=other.community)
FlagFactory(
content_object=post,
community=post.community,
)
assert get_external_flag_count(member.member, member.community) == 0
def test_get(self, client, member):
EventFactory.create_batch(
3,
community=member.community,
owner=MembershipFactory(community=member.community).member,
)
response = client.get(reverse("events:list"))
assert response.status_code == http.HTTPStatus.OK
assert len(dict(response.context_data or {})["object_list"]) == 3
def test_get_anonymous(self, client, community, anonymous_user):
user = MembershipFactory(
community=community, member=UserFactory(name="tester")
).member
response = client.get(reverse("users:autocomplete_list"), {"q": "tester"})
object_list = response.context["users"]
assert user in object_list
def test_post_user_blocking(self, client, member):
user = MembershipFactory(
community=member.community,
member=UserFactory(),
).member
member.member.blockers.add(user)
response = client.post(reverse("users:follow", args=[user.username]))
assert response.status_code == 404
assert user not in member.member.following.all()
def test_with_is_parent_owner_member_true(self, community):
parent = CommentFactory(
community=community,
owner=MembershipFactory(community=community).member,
)
comment = CommentFactory(
community=community,
parent=parent,
owner=MembershipFactory(community=community).member,
)
assert (
Comment.objects.with_is_parent_owner_member(community)
.for_community(community)
.get(pk=comment.id)
.is_parent_owner_member
)
def test_for_community(self, community: Community):
notification = NotificationFactory(
community=community,
actor=MembershipFactory(community=community).member,
)
NotificationFactory(actor=MembershipFactory(
community=community).member)
NotificationFactory(
actor=MembershipFactory(community=community, active=False).member)
NotificationFactory(actor=MembershipFactory(
community=CommunityFactory(), active=True).member)
NotificationFactory(community=community)
NotificationFactory()
qs = Notification.objects.for_community(community)
assert qs.count() == 1
assert qs.first() == notification