def test_can_see_groups_data_in_downloads_tab_content_only_if_there_are_groups(self):
##
# Let's create an experiment only with Experiment data, without
# groups data. With it, we simulate that Portal received an
# experiment, only with Experiment data.
##
owner = User.objects.get(username='******')
create_experiment(1, owner, Experiment.APPROVED)
experiment = Experiment.objects.last()
##
# We have to refresh page to include this new experiment in
# Experiments List
##
self.browser.refresh()
downloads_tab_content = self.access_downloads_tab_content(experiment)
# Now, as there're no data for groups, she sees a message telling
# her that there is only basic experiment data available to download
self.assertIn(
'There are not experiment groups data for this experiment. Click '
'in "Download" button to download basic experiment data',
downloads_tab_content.text
)
self.assertNotIn('Groups', downloads_tab_content.text)
self.assertNotIn(
'Experimental Protocol Data', downloads_tab_content.text
)
self.assertNotIn(
'Per Participant Data', downloads_tab_content.text
)
self.assertNotIn('Per Questionnaire data', downloads_tab_content.text)
self.assertNotIn('Participant ', downloads_tab_content.text)
def test_POSTing_new_experimental_protocol_with_image_creates_image_file(
self):
owner = User.objects.create_user(username='******', password='******')
experiment = create_experiment(1, owner, Experiment.TO_BE_ANALYSED)
group = create_group(1, experiment)
image_file = generate_image_file(filename='datei.jpg')
url = reverse('api_group_experimental_protocol-list',
kwargs={'pk': group.id})
self.client.login(username=owner.username, password='******')
response = self.client.post(
url, {
'image': image_file,
'textual_description': 'Ein wunderbar Beschreibung'
},
format='multipart')
self.client.logout()
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
new_exp_protocol = ExperimentalProtocol.objects.last()
self.assertEqual(new_exp_protocol.textual_description,
'Ein wunderbar Beschreibung')
self.assertTrue(
os.path.exists(
os.path.join(TEMP_MEDIA_ROOT, 'uploads',
datetime.utcnow().strftime('%Y/%m/%d'),
'datei.jpg')))
def test_delete_instance_deletes_its_files(self):
experiment = create_experiment(1)
file_instance = experiment.ethics_committee_file
add_temporary_file_to_file_instance(file_instance)
experiment.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def create_model_instances_to_test_step_type_data():
experiment = create_experiment(1)
group = create_group(1, experiment)
create_genders()
participant = create_participant(1, group,
Gender.objects.order_by('?').first())
return {
'experiment': experiment,
'group': group,
'participant': participant
}
def test_delete_instance_deletes_related_files(self):
experiment = create_experiment(1)
context_tree = create_context_tree(experiment)
file_instance = context_tree.setting_file
add_temporary_file_to_file_instance(file_instance)
context_tree.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def test_cannot_save_empty_attributes(self):
owner = User.objects.create_user(username='******',
password='******')
experiment = create_experiment(1,
owner=owner,
status=Experiment.TO_BE_ANALYSED)
group = create_group(1, experiment)
experimental_protocol = ExperimentalProtocol(group=group)
with self.assertRaises(ValidationError):
experimental_protocol.save()
experimental_protocol.full_clean()
def test_delete_instance_deletes_related_files(self):
experiment = create_experiment(1)
group = create_group(1, experiment)
stimulus = create_stimulus_step(group)
file_instance = stimulus.media_file
add_temporary_file_to_file_instance(file_instance)
stimulus.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def test_delete_instance_deletes_related_files(self):
experiment = create_experiment(1)
group = create_group(1, experiment)
experimental_protocol = create_experimental_protocol(group)
file_instance = experimental_protocol.image
add_temporary_file_to_file_instance(file_instance)
experimental_protocol.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def test_does_not_display_study_elements_if_they_not_exist(self):
owner = User.objects.create(username='******', password='******')
experiment = create_experiment(1, owner, Experiment.APPROVED)
##
# create study without end_date and keywords. We won't create
# contributors either
##
create_study(1, experiment)
##
# TODO:
# We have to refresh live server again because in parent setUp we
# already called it without new experiment created. When refactoring
# tests_helper call only in the classes setUp methods.
self.browser.get(self.browser.current_url)
# Jucileine clicks in the experiment approved
self.wait_for(
lambda:
self.browser.find_element_by_xpath(
"//a[@href='/experiments/" + experiment.slug + "/']"
).click()
)
# Jucileine clicks in From study link and sees a modal with Study
# data
self.wait_for(
lambda:
self.browser.find_element_by_link_text(
experiment.study.title).click()
)
# The modal pops up and she see the fields of the study
self.wait_for(lambda: self.assertIn(
experiment.study.title,
self.browser.find_element_by_id('modal_study_title').text
))
# As the study has no end date, no contributors and no keywords
# those fields did not appear in study modal
self.assertIn(
'No end date',
self.browser.find_element_by_id('study_enddate').text
)
self.assertNotIn(
'Contributors:',
self.browser.find_element_by_id('study_contributors').text
)
self.assertNotIn(
'Keywords:',
self.browser.find_element_by_id('keywords').text
)
def test_remove_experiment_display_message_removing(self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
stdout=out)
self.assertIn(
'Removing all versions of experiment "%s" data and files...' %
experiment.title, out.getvalue())
def test_delete_instance_deletes_related_files(self):
experiment = create_experiment(1)
eeg_setting = create_eeg_setting(1, experiment)
eeg_electrode_localization_system = \
create_eeg_electrode_localization_system(eeg_setting)
file_instance = eeg_electrode_localization_system.map_image_file
add_temporary_file_to_file_instance(file_instance)
eeg_electrode_localization_system.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def test_delete_instance_deletes_related_files(self):
experiment = create_experiment(1)
group = create_group(1, experiment)
step = create_step(1, group, Step.EEG)
step_additional_file = StepAdditionalFile.objects.create(step=step)
file_instance = step_additional_file.file
add_temporary_file_to_file_instance(file_instance)
step_additional_file.delete()
self.assertFalse(
os.path.exists(
os.path.join(self.TEMP_MEDIA_ROOT, file_instance.name)))
def test_can_see_groups_items_in_downloads_tab_content_only_if_they_exist(
self):
##
# Let's create an experiment with Experiment and Groups data. With
# it, we simulate that Portal received an experiment, only with
# Experiment and Group data. One group created has no data besides
# Group data, the other has 1 participant associated
##
owner = User.objects.get(username='******')
create_experiment(1, owner, Experiment.APPROVED)
experiment = Experiment.objects.last()
create_group(1, experiment)
group_with_nothing = Group.objects.last()
create_group(1, experiment)
create_participant(1, Group.objects.last(), Gender.objects.last())
##
# We have to refresh page to include this new experiment in
# Experiments List
##
self.browser.refresh()
downloads_tab_content = self.access_downloads_tab_content(experiment)
# As the last group created has only basic participant information (
# without data collection for it), that group is not listed.
self.assertNotIn(
'Group ' + experiment.groups.last().title,
downloads_tab_content.text
)
self.assertIn(
'There are not data for group ' +
group_with_nothing.title +
". But there's still basic Experiment data. Click in 'Download' "
"button to download it.",
downloads_tab_content.text
)
self.assertNotIn('Per Questionnaire Data', downloads_tab_content.text)
def test_remove_experiment_removes_uploads_subdir_if_there_are_not_files(
self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
uploads_subdir = os.path.join(self.TEMP_MEDIA_ROOT, 'uploads')
create_uploads_subdirs_and_files(uploads_subdir, empty=True)
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
stdout=out)
self.assertFalse(os.path.exists(uploads_subdir))
self.assertTrue(os.path.exists(self.TEMP_MEDIA_ROOT))
def test_remove_experiment_removes_all_versions(self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
experiment_versions = create_experiment_versions(11, experiment)
experiment_version = choice(experiment_versions)
out = StringIO()
call_command('remove_experiment',
experiment_version.nes_id,
experiment_version.owner,
stdout=out)
self.assertFalse(Experiment.objects.exists())
self.assertIn(
'All versions of experiment "%s" successfully removed' %
experiment.title, out.getvalue())
def test_remove_experiment_last_version_removes_objects_associated(
self, mock_user_input):
"""
Do not test for files deleted. This tests are made in models tests.
"""
# create experiment and some objects associated with it
experiment = create_experiment(1)
create_study(1, experiment)
groups = create_group(3, experiment)
eeg_setting = create_eeg_setting(1, experiment)
exp_prot = None # just to protect assert below
for group in groups:
exp_prot = create_experimental_protocol(group)
eeg_step = create_eeg_step(group, eeg_setting)
participants = create_participant(
3, group, gender=Gender.objects.order_by('?').first())
for participant in participants:
create_eeg_data(eeg_setting, eeg_step, participant)
# remove experiment last version and its related objects
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
'--last',
stdout=out)
# asserts
self.assertFalse(Experiment.objects.exists())
self.assertFalse(Study.objects.exists())
self.assertFalse(EEGSetting.objects.exists())
# TODO: fix this after fix tests helper (does not create model
# TODO: instances for all in it, create under demand in tests). Test
# TODO: for all objects at once.
for group in groups:
self.assertFalse(Group.objects.filter(pk=group.id).exists())
self.assertFalse(
ExperimentalProtocol.objects.filter(pk=exp_prot.id).exists())
self.assertFalse(EEG.objects.filter(group=group).exists())
self.assertFalse(group.participants.exists())
self.assertFalse(EEGData.objects.exists())
self.assertIn(
'Last version of experiment "%s" successfully removed' %
experiment.title, out.getvalue())
def test_remove_experiment_removes_uploads_subdirs_if_they_are_empty(
self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
uploads_subdir = os.path.join(self.TEMP_MEDIA_ROOT, 'uploads')
create_uploads_subdirs_and_files(uploads_subdir)
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
stdout=out)
for root, dirs, files in os.walk(uploads_subdir):
# it's in a path tree leaf wo files (e.g. 'uploads/2018/01/15')
if not dirs:
self.assertTrue(os.path.exists(root))
def test_remove_experiment_displays_prompt_and_user_confirm_removing(
self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
stdout=out)
self.assertEqual(mock_user_input.called, True)
(text, ), kwargs = mock_user_input.call_args
self.assertEqual(
text,
BaseCommand().style.WARNING(
'All versions of experiment "%s" will be destroyed and cannot be '
'recovered. Are you sure? (Yes/n) ' % experiment.title))
self.assertFalse(Experiment.objects.exists())
def test_remove_the_only_experiment_that_exists_removes_media_download_subdir(
self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
download_subdir = os.path.join(self.TEMP_MEDIA_ROOT, 'download',
str(experiment.id))
create_download_subdirs(download_subdir)
out = StringIO()
call_command('remove_experiment',
experiment.nes_id,
experiment.owner,
stdout=out)
self.assertFalse(os.path.exists(download_subdir))
self.assertFalse(
os.path.exists(os.path.join(self.TEMP_MEDIA_ROOT, 'download')))
def test_remove_experiment_last_version_removes_only_last_version(
self, mock_user_input):
owner = create_owner('labX')
experiment = create_experiment(1, owner=owner)
experiment_versions = create_experiment_versions(5, experiment)
experiment_version = choice(experiment_versions)
out = StringIO()
call_command('remove_experiment',
experiment_version.nes_id,
experiment_version.owner,
'--last',
stdout=out)
self.assertEqual(5, Experiment.objects.count())
self.assertEqual(5, Experiment.lastversion_objects.last().version)
self.assertIn(
'Last version of experiment "%s" successfully removed' %
experiment.title, out.getvalue())
def test_remove_experiment_removes_media_download_experiment_subdir(
self, mock_user_input):
owner = create_owner('labX')
experiments = create_experiment(2, owner=owner)
download_subdirs = []
for experiment in experiments:
download_subdir = os.path.join(self.TEMP_MEDIA_ROOT, 'download',
str(experiment.id))
create_download_subdirs(download_subdir)
download_subdirs.append(download_subdir)
out = StringIO()
call_command('remove_experiment',
experiments[0].nes_id,
experiments[0].owner,
stdout=out)
self.assertFalse(os.path.exists(download_subdirs[0]))
self.assertTrue(
os.path.exists(os.path.join(self.TEMP_MEDIA_ROOT, 'download')))
def create_basic_experiment_data():
owner = User.objects.create_user(username='******', password='******')
experiment = create_experiment(1, owner, Experiment.TO_BE_ANALYSED)
create_study(1, experiment)
return experiment
def setUp(self):
experiment = create_experiment(1)
group = create_group(1, experiment)
create_genders()
create_participant(1, group)
