def test_get_user_info(self):
team_owner = TeamFactory(owner=self.user)
team_member = TeamFactory(members=[self.user])
response = self.fetch_with_headers("/user/info/%s" % self.user.email)
expect(response.code).to_equal(200)
body = response.body
if isinstance(body, six.binary_type):
body = body.decode('utf-8')
body = loads(body)
expect(body['user']['email']).to_equal(self.user.email)
owner_team = [
team for team in body['user']['teams'] if team['role'] == 'owner'
]
member_team = [
team for team in body['user']['teams'] if team['role'] == 'member'
]
expect(owner_team).to_length(1)
expect(member_team).to_length(1)
expect(owner_team[0]['name']).to_equal(team_owner.name)
expect(member_team[0]['name']).to_equal(team_member.name)
def test_team_update_delete_permissions(client, TwoChallengeSets, view):
team = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant,
)
TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant1,
)
validate_owner_or_admin_view(
viewname=view,
reverse_kwargs={'pk': team.pk},
two_challenge_set=TwoChallengeSets,
client=client,
)
def test_update_or_create(monkeypatch, db):
user = UserFactory()
team_1 = TeamFactory(name=("Team 1"), _base_log_user=user)
team_2 = TeamFactory(name=("Team 2"), _base_log_user=user)
player = PlayerFactory(name=(player_name := "Player"),
team=team_1,
_base_log_user=user)
def save_signal(sender, **kwargs):
assert sender == Player
assert kwargs["obj"].pk is player.pk
assert kwargs["obj"].name == player_name
assert kwargs["obj"].team == team_2
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_create.send",
save_signal)
Player.objects.update_or_create(name=player_name,
team=team_1,
defaults={"team": team_2},
_base_log_user=user)
assert Player.objects.count() == 1
new_player_name = "Player 2"
def save_signal(sender, **kwargs):
assert sender == Player
assert kwargs["obj"].pk is not None
assert kwargs["obj"].name == new_player_name
assert kwargs["obj"].team == team_2
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_create.send",
save_signal)
Player.objects.update_or_create(
name=new_player_name,
team=team_1,
defaults={"team": team_2},
_base_log_user=user,
)
assert Player.objects.count() == 2
def test_open_views(client, ChallengeSet):
team = TeamFactory(challenge=ChallengeSet.challenge,
owner=ChallengeSet.participant)
validate_open_view(
viewname='teams:detail',
reverse_kwargs={'pk': team.pk},
challenge_set=ChallengeSet,
client=client,
)
def test_open_views(client, challenge_set):
team = TeamFactory(
challenge=challenge_set.challenge, owner=challenge_set.participant
)
validate_open_view(
viewname="teams:detail",
reverse_kwargs={"pk": team.pk},
challenge_set=challenge_set,
client=client,
)
def test_invalid_team(self):
user = UserFactory()
team = TeamFactory()
member = TeamMemberFactory(user=user, role='owner')
data = {
'member_obj': member.pk
}
form = forms.TeamMemberRemoveForm(data=data, team=team)
assert not form.is_valid()
def test_duplicate(self):
user = UserFactory()
team = TeamFactory()
TeamMemberFactory(user=user, team=team, role='owner')
data = {
'user': user.pk,
'role': 'owner',
}
form = forms.TeamMemberAddForm(data=data, team=team)
assert not form.is_valid()
def test_save_add(self):
team = TeamFactory()
repository = RepositoryFactory()
data = {
'team': team.pk,
}
form = forms.RepositoryTeamForm(data, repository=repository)
assert form.is_valid()
form.save()
assert repository.teams.count() == 1
def test_team_member_delete_permissions(client, TwoChallengeSets):
team = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant,
)
team_member = TeamMemberFactory(
team=team, user=TwoChallengeSets.ChallengeSet1.participant1)
validate_member_owner_or_admin_view(
viewname='teams:member-delete',
reverse_kwargs={'pk': team_member.pk},
two_challenge_set=TwoChallengeSets,
client=client,
)
def test_save(self):
user = UserFactory()
team = TeamFactory()
member = TeamMemberFactory(user=user, team=team, role='owner')
data = {
'member_obj': member.pk
}
form = forms.TeamMemberRemoveForm(data=data, team=team)
assert form.is_valid()
cleaned_data = form.clean()
assert cleaned_data == {'member_obj': member}
def test_team_member_delete_permissions(client, two_challenge_sets):
team = TeamFactory(
challenge=two_challenge_sets.challenge_set_1.challenge,
owner=two_challenge_sets.challenge_set_1.participant,
)
team_member = TeamMemberFactory(
team=team, user=two_challenge_sets.challenge_set_1.participant1
)
validate_member_owner_or_admin_view(
viewname="teams:member-delete",
reverse_kwargs={"pk": team_member.pk},
two_challenge_set=two_challenge_sets,
client=client,
)
def test_admin_or_participant_permissions(client, TwoChallengeSets, view):
team = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant,
)
if view in ('teams:detail', 'teams:member-create'):
pk = team.pk
else:
pk = None
validate_admin_or_participant_view(
viewname=view,
reverse_kwargs={'pk': pk},
two_challenge_set=TwoChallengeSets,
client=client,
)
def test_update(monkeypatch, db):
user = UserFactory()
team_1 = TeamFactory(name="Team 1", _base_log_user=user)
team_2 = TeamFactory(name="Team 2", _base_log_user=user)
def update_signal(sender, **kwargs):
assert sender == Team
objs = list(kwargs["objs"])
assert len(objs) == 2
assert objs[0].pk == team_1.pk
assert objs[0].name == "Team"
assert objs[1].pk == team_2.pk
assert objs[1].name == "Team"
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_update.send",
update_signal)
Team.objects.all().update(name="Team", _base_log_user=user)
def test_admin_or_participant_permissions(client, two_challenge_sets, view):
team = TeamFactory(
challenge=two_challenge_sets.challenge_set_1.challenge,
owner=two_challenge_sets.challenge_set_1.participant,
)
if view in ("teams:detail", "teams:member-create"):
pk = team.pk
else:
pk = None
validate_admin_or_participant_view(
viewname=view,
reverse_kwargs={"pk": pk},
two_challenge_set=two_challenge_sets,
client=client,
)
def test_save(self):
user = UserFactory()
team = TeamFactory()
data = {
'user': user.pk,
'role': 'owner',
}
form = forms.TeamMemberAddForm(data=data, team=team)
assert form.is_valid()
form.save()
assert team.users.count() == 1
member = team.members.first()
assert member.user == user
assert member.role == 'owner'
def test_team_member_addition(client, TwoChallengeSets):
team = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant,
)
assert TwoChallengeSets.ChallengeSet1.participant in team.get_members()
assert TwoChallengeSets.ChallengeSet1.participant1 not in team.get_members()
# Participant1 requests to join team
response = get_view_for_user(
viewname="teams:member-create",
challenge=TwoChallengeSets.ChallengeSet1.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.ChallengeSet1.participant1,
reverse_kwargs={"pk": team.pk},
)
assert TwoChallengeSets.ChallengeSet1.participant1 in team.get_members()
assert response.status_code == 302
def test_get_or_create(monkeypatch, db):
user = UserFactory()
TeamFactory(name=(team_1_name := "Team 1"), _base_log_user=user)
Team.objects.get_or_create(name=team_1_name, _base_log_user=user)
assert Team.objects.count() == 1
team_2_name = "Team 2"
def save_signal(sender, **kwargs):
assert sender == Team
assert kwargs["obj"].pk is not None
assert kwargs["obj"].name == team_2_name
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_create.send",
save_signal)
Team.objects.get_or_create(name=team_2_name, _base_log_user=user)
assert Team.objects.count() == 2
def test_bulk_delete(monkeypatch, db):
user = UserFactory()
team_1 = TeamFactory(name=(team_1_name := "Team 1"), _base_log_user=user)
team_2 = TeamFactory(name=(team_2_name := "Team 2"), _base_log_user=user)
player_1 = PlayerFactory(name=(player_1_name := "Player 1"),
team=team_1,
_base_log_user=user)
player_2 = PlayerFactory(name=(player_2_name := "Player 2"),
team=team_2,
_base_log_user=user)
player_3 = PlayerFactory(
name=(player_3_name := "Player 3"),
team=team_2,
is_active=True,
_base_log_user=user,
)
# It is not possible to delete all teams because 3rd player is active and it is not possible
# to delete him
with pytest.raises(ValidationError):
Team.objects.all().delete(_base_log_user=user)
assert Team.objects.count() == 2
assert Player.objects.count() == 3
player_3.is_active = False
player_3.save(_base_log_user=user)
def bulk_delete_signal(sender, **kwargs):
assert sender in (Team, Player)
objs = list(kwargs["objs"])
if sender == Team:
assert len(objs) == 2
assert objs[0].pk == team_1.pk
assert objs[0].name == team_1_name
assert objs[1].pk == team_2.pk
assert objs[1].name == team_2_name
if sender == Player:
assert len(objs) == 3
assert objs[0].pk == player_1.pk
assert objs[0].name == player_1_name
assert objs[1].pk == player_2.pk
assert objs[1].name == player_2_name
assert objs[2].pk == player_3.pk
assert objs[2].name == player_3_name
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_bulk_delete.send",
bulk_delete_signal)
Team.objects.all().delete(_base_log_user=user)
assert Team.objects.count() == 0
assert Player.objects.count() == 0
def test_unique_membership(client, TwoChallengeSets):
team = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant,
)
team1 = TeamFactory(
challenge=TwoChallengeSets.ChallengeSet1.challenge,
owner=TwoChallengeSets.ChallengeSet1.participant1,
)
# Try to create a new team, should be denied
response = get_view_for_user(
viewname='teams:create',
challenge=TwoChallengeSets.ChallengeSet1.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.ChallengeSet1.participant,
data={'name': 'thisteamshouldnotbecreated'},
)
assert response.status_code == 200
assert 'You are already a member of another team for this challenge' in response.rendered_content
# Participant1 requests to join team, should be denied
response = get_view_for_user(
viewname='teams:member-create',
challenge=TwoChallengeSets.ChallengeSet1.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.ChallengeSet1.participant1,
reverse_kwargs={'pk': team.pk},
)
assert response.status_code == 200
assert 'You are already a member of another team for this challenge' in response.rendered_content
# participant12 should be able to create a team in their challenge and join another
response = get_view_for_user(
viewname='teams:create',
challenge=TwoChallengeSets.ChallengeSet2.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.participant12,
data={'name': 'thisteamshouldbecreated'},
)
assert response.status_code == 302
response = get_view_for_user(
viewname='teams:member-create',
challenge=TwoChallengeSets.ChallengeSet1.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.participant12,
reverse_kwargs={'pk': team.pk},
)
assert response.status_code == 302
assert TwoChallengeSets.participant12 in team.get_members()
response = get_view_for_user(
viewname='teams:member-create',
challenge=TwoChallengeSets.ChallengeSet1.challenge,
client=client,
method=client.post,
user=TwoChallengeSets.participant12,
reverse_kwargs={'pk': team1.pk},
)
assert response.status_code == 200
assert 'You are already a member of another team for this challenge' in response.rendered_content
def test_delete(monkeypatch, db):
user = UserFactory()
team = TeamFactory(name=(team_name := "Team"), _base_log_user=user)
player = PlayerFactory(name=(player_name := "Player"),
team=team,
_base_log_user=user)
def delete_signal(sender, **kwargs):
assert sender == Team
assert kwargs["obj"].pk is not None
assert kwargs["obj"].name == team_name
assert kwargs["user"] == user
def bulk_delete_signal(sender, **kwargs):
assert sender == Player
assert kwargs["objs"].count() == 1
assert kwargs["objs"][0].pk is not None
assert kwargs["objs"][0].name == player_name
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_delete.send",
delete_signal)
monkeypatch.setattr("django_base_model.signals.base_bulk_delete.send",
bulk_delete_signal)
# Test that Foreign Key CASCADE relations (in this case player) are deleted
team.delete(_base_log_user=user)
with pytest.raises(ObjectDoesNotExist):
player.refresh_from_db()
# ------------------------------------------------------------------------------------------- #
team = TeamFactory(name=team_name, _base_log_user=user)
player = PlayerFactory(name=player_name, team=team, _base_log_user=user)
training = PlayerTrainingFactory(player=player,
description=(description :=
"Description"),
_base_log_user=user)
def delete_signal(sender, **kwargs):
assert sender in (Player, PlayerTraining)
assert kwargs["obj"].pk is not None
if sender == Player:
assert kwargs["obj"].name == player_name
elif sender == PlayerTraining:
assert kwargs["obj"].description == description
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_delete.send",
delete_signal)
# Test that OneToOneField CASCADE relation (in this case training) is deleted
player.delete(_base_log_user=user)
with pytest.raises(ObjectDoesNotExist):
training.refresh_from_db()
# ------------------------------------------------------------------------------------------- #
player = PlayerFactory(name=player_name, team=team, _base_log_user=user)
training = PlayerTrainingFactory(player=player,
description=description,
is_active=True,
_base_log_user=user)
assert Player.objects.count() == 1
assert PlayerTraining.objects.count() == 1
# Test that error is raised because it is not possible to delete active training which
# would be deleted because of CASCADE deletion
with pytest.raises(ValidationError):
player.delete(_base_log_user=user)
assert Player.objects.count() == 1
assert PlayerTraining.objects.count() == 1
# ------------------------------------------------------------------------------------------- #
player = PlayerFactory(name=player_name,
team=team,
is_active=True,
_base_log_user=user)
assert Team.objects.count() == 1
assert Player.objects.count() == 2
def delete_signal(sender, **kwargs):
assert sender == Team
assert kwargs["obj"].pk is not None
assert kwargs["obj"].name == team_name
assert kwargs["user"] == user
monkeypatch.setattr("django_base_model.signals.base_delete.send",
delete_signal)
# Test that error is raised because it is not possible to delete active players who
# would be deleted because of CASCADE deletion
with pytest.raises(ValidationError):
team.delete(_base_log_user=user)
assert Team.objects.count() == 1
assert Player.objects.count() == 2
def test_unique_membership(client, two_challenge_sets):
team = TeamFactory(
challenge=two_challenge_sets.challenge_set_1.challenge,
owner=two_challenge_sets.challenge_set_1.participant,
)
team1 = TeamFactory(
challenge=two_challenge_sets.challenge_set_1.challenge,
owner=two_challenge_sets.challenge_set_1.participant1,
)
# Try to create a new team, should be denied
response = get_view_for_user(
viewname="teams:create",
challenge=two_challenge_sets.challenge_set_1.challenge,
client=client,
method=client.post,
user=two_challenge_sets.challenge_set_1.participant,
data={"name": "thisteamshouldnotbecreated"},
)
assert response.status_code == 200
assert (
"You are already a member of another team for this challenge"
in response.rendered_content
)
# Participant1 requests to join team, should be denied
response = get_view_for_user(
viewname="teams:member-create",
challenge=two_challenge_sets.challenge_set_1.challenge,
client=client,
method=client.post,
user=two_challenge_sets.challenge_set_1.participant1,
reverse_kwargs={"pk": team.pk},
)
assert response.status_code == 200
assert (
"You are already a member of another team for this challenge"
in response.rendered_content
)
# participant12 should be able to create a team in their challenge and join
# another team
response = get_view_for_user(
viewname="teams:create",
challenge=two_challenge_sets.challenge_set_2.challenge,
client=client,
method=client.post,
user=two_challenge_sets.participant12,
data={"name": "thisteamshouldbecreated"},
)
assert response.status_code == 302
response = get_view_for_user(
viewname="teams:member-create",
challenge=two_challenge_sets.challenge_set_1.challenge,
client=client,
method=client.post,
user=two_challenge_sets.participant12,
reverse_kwargs={"pk": team.pk},
)
assert response.status_code == 302
assert two_challenge_sets.participant12 in team.get_members()
response = get_view_for_user(
viewname="teams:member-create",
challenge=two_challenge_sets.challenge_set_1.challenge,
client=client,
method=client.post,
user=two_challenge_sets.participant12,
reverse_kwargs={"pk": team1.pk},
)
assert response.status_code == 200
assert (
"You are already a member of another team for this challenge"
in response.rendered_content
)
