def test_save(monkeypatch, db):
user = UserFactory()
team = Team(name=(team_name := "Team"))
def setUp(self):
super(TestExternalProviderOAuth2, self).setUp()
self.user = UserFactory()
self.provider = MockOAuth2Provider()
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], self.short_name)
def test_must_be_logged_in_decorator_with_user(self, mock_from_kwargs):
user = UserFactory()
mock_from_kwargs.return_value = Auth(user=user)
protected()
def test_get_user_by_id(self):
user = UserFactory()
assert_equal(User.load(user._id), user)
def setUp(self):
super(TestSendRetractionAndEmbargoAdditionMessage, self).setUp()
self.registration_contrib = UserFactory()
self.other_user = UserFactory()
self.registration = RegistrationFactory(
creator=self.registration_contrib)
def test_logged_in(self):
user = UserFactory()
auth_obj = Auth(user=user)
assert_true(auth_obj.logged_in)
auth2 = Auth(user=None)
assert_false(auth2.logged_in)
def test_repr(self):
self.user_settings.owner = UserFactory()
assert_in(self.user_settings.owner._id, repr(self.user_settings))
oauth_settings = GitHubOauthSettingsFactory()
def test_before_page_load_not_contributor(self):
message = self.node_settings.before_page_load(self.project,
UserFactory())
assert_false(message)
def test_get_user_ids_for_site(self):
expected_users = [UserFactory() for i in range(3)]
with mock.patch('figures.helpers.settings.FEATURES', self.features):
user_ids = figures.sites.get_user_ids_for_site(self.site)
assert set(user_ids) == set([user.id for user in expected_users])
def test_permission_required_views(self, client):
e = EvaluationFactory()
u = UserFactory()
VerificationFactory(user=u, is_verified=True)
for view_name, kwargs, permission, obj in [
(
"phase-create",
{},
"change_challenge",
e.submission.phase.challenge,
),
(
"phase-update",
{"slug": e.submission.phase.slug},
"change_phase",
e.submission.phase,
),
(
"method-create",
{},
"change_challenge",
e.submission.phase.challenge,
),
("method-detail", {"pk": e.method.pk}, "view_method", e.method),
(
"submission-create",
{"slug": e.submission.phase.slug},
"create_phase_submission",
e.submission.phase,
),
(
"submission-create-legacy",
{"slug": e.submission.phase.slug},
"change_challenge",
e.submission.phase.challenge,
),
(
"submission-detail",
{"pk": e.submission.pk},
"view_submission",
e.submission,
),
("update", {"pk": e.pk}, "change_evaluation", e),
("detail", {"pk": e.pk}, "view_evaluation", e),
]:
response = get_view_for_user(
client=client,
viewname=f"evaluation:{view_name}",
reverse_kwargs={
"challenge_short_name": e.submission.phase.challenge.short_name,
**kwargs,
},
user=u,
)
assert response.status_code == 403
assign_perm(permission, u, obj)
response = get_view_for_user(
client=client,
viewname=f"evaluation:{view_name}",
reverse_kwargs={
"challenge_short_name": e.submission.phase.challenge.short_name,
**kwargs,
},
user=u,
)
assert response.status_code == 200
remove_perm(permission, u, obj)
def setUp(self):
super(TestMigrateRegistrationExtra, self).setUp()
self.user = UserFactory()
self.node = ProjectFactory(creator=self.user)
self.prereg_schema = get_prereg_schema()
self.file = self._get_test_file()
self.data = {
'uploader': {
'extra': {
'hasSelectedFile': True,
'nodeId': self.node._id,
'selectedFileName': 'file.txt',
'sha256': fake.sha256(),
'viewUrl': '/project/{}/files/osfstorage/5723787136b74e1a953d9612/'.format(
self.node._id
)
},
'value': 'file.txt'
},
'other': {
'value': 'foo'
},
'bad': {
'value': 'foobarbaz',
'extra': [
{
'viewUrl': '/project/{}/files/osfstorage/5723787136b74e1a953d9612/'.format(
self.node._id
),
'hasSelectedFile': True,
'selectedFileName': 'file.txt'
}
]
},
'nested': {
'value': {
'uploader': {
'extra': {
'hasSelectedFile': True,
'nodeId': self.node._id,
'selectedFileName': 'file.txt',
'sha256': fake.sha256(),
'viewUrl': '/project/{}/files/osfstorage/5723787136b74e1a953d9612/'.format(
self.node._id
)
},
'value': 'file.txt'
},
'question': {
'value': 'bar',
'extra': {}
},
'other': {
'value': 'foo',
'extra': []
}
}
}
}
def setUp(self):
super(TestUserSettingsModel, self).setUp()
self.user = UserFactory()
def test_example_ground_truth(client, tmpdir):
rs = ReaderStudyFactory()
reader, editor = UserFactory(), UserFactory()
q1, q2, q3 = (
QuestionFactory(
reader_study=rs,
question_text="q1",
answer_type=Question.AnswerType.BOOL,
),
QuestionFactory(
reader_study=rs,
question_text="q2",
answer_type=Question.AnswerType.CHOICE,
),
QuestionFactory(
reader_study=rs,
question_text="q3",
answer_type=Question.AnswerType.SINGLE_LINE_TEXT,
),
)
CategoricalOptionFactory(question=q2, title="option")
im1, im2, im3 = (ImageFactory(), ImageFactory(), ImageFactory())
rs.images.set([im1, im2, im3])
rs.add_reader(reader)
rs.add_editor(editor)
rs.generate_hanging_list()
response = get_view_for_user(
viewname="reader-studies:example-ground-truth",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug},
follow=True,
user=reader,
)
assert response.status_code == 403
response = get_view_for_user(
viewname="reader-studies:example-ground-truth",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug},
follow=True,
user=editor,
)
assert response.status_code == 200
assert Answer.objects.count() == 0
gt = io.BytesIO()
gt.write(response.content)
gt.seek(0)
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
follow=True,
data={"ground_truth": gt},
user=editor,
)
assert response.status_code == 200
assert Answer.objects.count() == rs.images.count() * rs.questions.count()
for image in [im1, im2, im3]:
for question in [q1, q2, q3]:
assert Answer.objects.filter(images=image,
question=question,
is_ground_truth=True).exists()
def test_bulk_create(monkeypatch, db):
user = UserFactory()
team_1 = Team(name=(team_1_name := "Team 1"))
def test_get_user_by_email(self):
user = UserFactory()
assert_equal(auth.get_user(email=user.username), user)
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_cant_get_if_not_team_member(self):
self.user = UserFactory(with_token=True)
response = self.fetch_with_headers("/teams/%s/projects/%s" %
(self.team.name, "whatever"))
expect(response.code).to_equal(403)
