def test_mock_connection(self):
# A connection with bad credentials fails
failed_connection = create_mock_connection('wrong', 'info')
assert_false(failed_connection)
# A good connection has the correct parameters
mock_connection = create_mock_connection()
assert_equal(mock_connection.username, 'snowman')
assert_equal(mock_connection.password, 'frosty')
assert_equal(len(mock_connection.get_dataverses()), 3)
assert_is_instance(mock_connection.get_dataverses()[0], Dataverse)
assert_equal(
mock_connection.get_dataverse(mock_connection.get_dataverses()[1].alias),
mock_connection.get_dataverses()[1],
)
def test_set_user_config_fail(self, mock_connection):
mock_connection.return_value = create_mock_connection('wrong', 'info')
# Create a user with no settings
user = AuthUserFactory()
user.add_addon('dataverse')
user_settings = user.get_addon('dataverse')
url = api_url_for('dataverse_set_user_config')
params = {'dataverse_username': '******',
'dataverse_password': '******'}
# Post incorrect credentials to existing user
res = self.app.post_json(url, params, auth=self.user.auth,
expect_errors=True)
self.user_settings.reload()
# Original user's info has not changed
assert_equal(res.status_code, http.UNAUTHORIZED)
assert_equal(self.user_settings.dataverse_username, 'snowman')
assert_equal(self.user_settings.dataverse_password, 'frosty')
# Post incorrect credentials to new user
res = self.app.post_json(url, params, auth=user.auth,
expect_errors=True)
user_settings.reload()
# New user's incorrect credentials were not saved
assert_equal(res.status_code, http.UNAUTHORIZED)
assert_equal(user_settings.dataverse_username, None)
assert_equal(user_settings.dataverse_password, None)
def test_set_user_config_fail(self, mock_connection):
mock_connection.return_value = create_mock_connection('wrong', 'info')
# Create a user with no settings
user = AuthUserFactory()
user.add_addon('dataverse')
user_settings = user.get_addon('dataverse')
url = api_url_for('dataverse_set_user_config')
params = {'dataverse_username': '******', 'dataverse_password': '******'}
# Post incorrect credentials to existing user
res = self.app.post_json(url,
params,
auth=self.user.auth,
expect_errors=True)
self.user_settings.reload()
# Original user's info has not changed
assert_equal(res.status_code, http.UNAUTHORIZED)
assert_equal(self.user_settings.dataverse_username, 'snowman')
assert_equal(self.user_settings.dataverse_password, 'frosty')
# Post incorrect credentials to new user
res = self.app.post_json(url,
params,
auth=user.auth,
expect_errors=True)
user_settings.reload()
# New user's incorrect credentials were not saved
assert_equal(res.status_code, http.UNAUTHORIZED)
assert_equal(user_settings.dataverse_username, None)
assert_equal(user_settings.dataverse_password, None)
def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
mock_upload, mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_get_by_id.return_value = None # To confirm deletion happened
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
path = '54321'
payload = {'file': Upload(filename, content,'text/x-rst')}
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key, path=path)
res = self.app.post(url, payload, auth=self.user.auth)
# Old file was deleted
mock_delete.assert_called_once
# File was uploaded
assert_equal(res.status_code, http.CREATED)
mock_upload.assert_called_once
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
assert_equal('file_updated', json.loads(res.body)['actionTaken'])
def test_dataverse_root_not_published(self, mock_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_files.return_value = []
self.project.set_privacy('public')
self.project.save()
alias = self.node_settings.dataverse_alias
doi = self.node_settings.dataset_doi
external_account = create_external_account()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(external_account, self.user)
self.node_settings.dataverse_alias = alias
self.node_settings.dataset_doi = doi
self.node_settings.save()
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
# Contributor gets draft, no options
res = self.app.get(url, auth=self.user.auth)
assert_true(res.json[0]['permissions']['edit'])
assert_false(res.json[0]['hasPublishedFiles'])
assert_equal(res.json[0]['version'], 'latest')
# Non-contributor gets nothing
user2 = AuthUserFactory()
res = self.app.get(url, auth=user2.auth)
assert_equal(res.json, [])
def test_upload_too_small(self, mock_get, mock_delete, mock_upload,
mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'baz'
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
expect_errors=True,
)
# Old file was not deleted
assert_false(mock_delete.call_count)
# Bad request
assert_equal(res.status_code, http.UNSUPPORTED_MEDIA_TYPE)
assert_false(mock_upload.call_count)
def test_dataverse_add_external_account_existing(self, mock_connection):
mock_connection.return_value = create_mock_connection()
host = 'myfakehost.data.verse'
token = 'dont-use-this-token-in-other-tests'
display_name = 'loaded_version'
# Save an existing version
external_account = ExternalAccount(
provider='dataverse',
provider_name='Dataverse',
display_name=display_name,
oauth_key=host,
oauth_secret=token,
provider_id=token,
)
external_account.save()
url = api_url_for('dataverse_add_user_account')
params = {'host': host, 'api_token': token}
self.app.post_json(url, params, auth=self.user.auth)
self.user.reload()
assert_equal(len(self.user.external_accounts), 1)
external_account = self.user.external_accounts[0]
assert_equal(external_account.provider, 'dataverse')
assert_equal(external_account.oauth_key, host)
assert_equal(external_account.oauth_secret, token)
# Ensure we got the loaded version
assert_equal(external_account.display_name, display_name)
def test_dataverse_release_study(self, mock_release, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_release_study',
pid=self.project._primary_key)
self.app.put(url, auth=self.user.auth)
assert_true(mock_release.called)
def test_set_dataverse_no_dataset(self, mock_connection):
mock_connection.return_value = create_mock_connection()
num_old_logs = len(self.project.logs)
url = api_url_for('dataverse_set_config',
pid=self.project._primary_key)
params = {
'dataverse': {'alias': 'ALIAS3'},
'dataset': {}, # The dataverse has no datasets
}
# Select a different dataset
res = self.app.post_json(url, params, auth=self.user.auth,
expect_errors=True)
self.node_settings.reload()
# Old settings did not change
assert_equal(res.status_code, http.BAD_REQUEST)
assert_equal(self.node_settings.dataverse_alias, 'ALIAS2')
assert_equal(self.node_settings.dataset, 'Example (DVN/00001)')
assert_equal(self.node_settings.dataset_doi, 'doi:12.3456/DVN/00001')
# Nothing was logged
self.project.reload()
assert_equal(len(self.project.logs), num_old_logs)
def test_set_dataverse_and_dataset(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_set_config',
pid=self.project._primary_key)
params = {
'dataverse': {'alias': 'ALIAS3'},
'dataset': {'doi': 'doi:12.3456/DVN/00003'},
}
# Select a different dataset
self.app.post_json(url, params, auth=self.user.auth)
self.project.reload()
self.node_settings.reload()
# New dataset was selected
assert_equal(self.node_settings.dataverse_alias, 'ALIAS3')
assert_equal(self.node_settings.dataset, 'Example (DVN/00003)')
assert_equal(self.node_settings.dataset_doi, 'doi:12.3456/DVN/00003')
assert_equal(self.node_settings.dataset_id, '18')
# Log states that a dataset was selected
last_log = self.project.logs[-1]
assert_equal(last_log.action, 'dataverse_dataset_linked')
log_params = last_log.params
assert_equal(log_params['node'], self.project._primary_key)
assert_is_none(log_params['project'])
assert_equal(log_params['dataset'], 'Example (DVN/00003)')
def test_upload_too_small(self, mock_get, mock_delete, mock_upload,
mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'baz'
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key, name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
expect_errors=True,
)
# Old file was not deleted
assert_false(mock_delete.call_count)
# Bad request
assert_equal(res.status_code, http.UNSUPPORTED_MEDIA_TYPE)
assert_false(mock_upload.call_count)
def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
mock_upload, mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_get_by_id.return_value = None # To confirm deletion happened
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key, name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
)
# Old file was deleted
mock_delete.assert_called_once()
# File was uploaded
assert_equal(res.status_code, http.OK)
mock_upload.assert_called_once()
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
def test_upload_file(self, mock_get, mock_upload, mock_connection):
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
# Upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key, name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
)
# File was uploaded
assert_equal(res.status_code, http.CREATED)
mock_upload.assert_called_once()
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
def test_fail_if_unauthorized_forbidden(self, mock_get_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
with assert_raises(HTTPError) as error:
fail_if_unauthorized(self.node_settings, self.user.auth, 'bar')
assert_equal(error.code, http.FORBIDDEN)
def test_set_dataverse_and_study(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('set_dataverse_and_study',
pid=self.project._primary_key)
params = {
'dataverse': {
'alias': 'ALIAS3'
},
'study': {
'hdl': 'doi:12.3456/DVN/00003'
},
}
# Select a different study
self.app.post_json(url, params, auth=self.user.auth)
self.project.reload()
self.node_settings.reload()
# New study was selected
assert_equal(self.node_settings.dataverse_alias, 'ALIAS3')
assert_equal(self.node_settings.study, 'Example (DVN/00003)')
assert_equal(self.node_settings.study_hdl, 'doi:12.3456/DVN/00003')
# Log states that a study was selected
last_log = self.project.logs[-1]
assert_equal(last_log.action, 'dataverse_study_linked')
log_params = last_log.params
assert_equal(log_params['node'], self.project._primary_key)
assert_is_none(log_params['project'])
assert_equal(log_params['study'], 'Example (DVN/00003)')
def test_serialize_settings_helper_returns_correct_auth_info(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = self.serializer.serialized_node_settings
assert_equal(result['nodeHasAuth'], self.node_settings.has_auth)
assert_true(result['userHasAuth'])
assert_true(result['userIsOwner'])
def test_dataverse_publish_dataset(self, mock_publish, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_publish_dataset',
pid=self.project._primary_key)
self.app.put(url, auth=self.user.auth)
assert_true(mock_publish.called)
def test_upload_file(self, mock_get, mock_upload, mock_connection):
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
# Upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
)
# File was uploaded
assert_equal(res.status_code, http.CREATED)
mock_upload.assert_called_once()
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
mock_upload, mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_get_by_id.return_value = None # To confirm deletion happened
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
path = '54321'
payload = {'file': Upload(filename, content, 'text/x-rst')}
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
path=path)
res = self.app.post(url, payload, auth=self.user.auth)
# Old file was deleted
mock_delete.assert_called_once
# File was uploaded
assert_equal(res.status_code, http.CREATED)
mock_upload.assert_called_once
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
assert_equal('file_updated', json.loads(res.body)['actionTaken'])
def test_fail_if_unauthorized_forbidden(self, mock_get_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
with assert_raises(HTTPError) as error:
fail_if_unauthorized(self.node_settings, self.user.auth, 'bar')
assert_equal(error.code, http.FORBIDDEN)
def test_dataverse_publish_dataset(self, mock_publish, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_publish_dataset',
pid=self.project._primary_key)
self.app.put(url, auth=self.user.auth)
assert_true(mock_publish.called)
def test_upload_too_small(self, mock_get, mock_delete, mock_upload,
mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'baz'
path = '54321'
payload = {'file': Upload(filename, content, 'text/x-rst')}
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
path=path)
res = self.app.post(url,
payload,
auth=self.user.auth,
expect_errors=True)
# Old file was not deleted
assert_false(mock_delete.call_count)
# Bad request
assert_equal(res.status_code, http.UNSUPPORTED_MEDIA_TYPE)
assert_false(mock_upload.call_count)
def test_dataverse_root_draft(self, mock_files, mock_request,
mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
mock_request.args = {'state': 'draft'}
mock_files.return_value = ['mock_file']
self.project.set_privacy('public')
self.project.save()
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
# Contributor can select between states, current state is correct
res = self.app.get(url, auth=self.user.auth)
assert_in('draft', res.json[0]['urls']['fetch'])
assert_true(res.json[0]['permissions']['edit'])
assert_in('<option value="draft" selected>', res.json[0]['extra'])
# Non-contributor gets released version, no options
user2 = AuthUserFactory()
res = self.app.get(url, auth=user2.auth)
assert_in('released', res.json[0]['urls']['fetch'])
assert_false(res.json[0]['permissions']['edit'])
assert_not_in('select', res.json[0]['extra'])
def test_dataverse_release_study(self, mock_release, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_release_study',
pid=self.project._primary_key)
res = self.app.put(url, auth=self.user.auth)
assert_true(mock_release.called)
def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
mock_upload, mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_get_by_id.return_value = None # To confirm deletion happened
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
name=filename)
res = self.app.put(
url,
params=content,
auth=self.user.auth,
headers={'Content-Type': 'application/octet-stream'},
)
# Old file was deleted
mock_delete.assert_called_once()
# File was uploaded
assert_equal(res.status_code, http.OK)
mock_upload.assert_called_once()
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
def test_mock_connection(self):
# A connection with bad credentials fails
failed_connection = create_mock_connection('wrong', 'info')
assert_false(failed_connection)
# A good connection has the correct parameters
mock_connection = create_mock_connection()
assert_equal(mock_connection.username, 'snowman')
assert_equal(mock_connection.password, 'frosty')
assert_equal(len(mock_connection.get_dataverses()), 3)
assert_is_instance(mock_connection.get_dataverses()[0], Dataverse)
assert_equal(
mock_connection.get_dataverse(
mock_connection.get_dataverses()[1].alias),
mock_connection.get_dataverses()[1],
)
def test_set_dataverse_no_study(self, mock_connection):
mock_connection.return_value = create_mock_connection()
num_old_logs = len(self.project.logs)
url = api_url_for('set_dataverse_and_study',
pid=self.project._primary_key)
params = {
'dataverse': {
'alias': 'ALIAS3'
},
'study': {}, # The dataverse has no studies
}
# Select a different study
res = self.app.post_json(url,
params,
auth=self.user.auth,
expect_errors=True)
self.node_settings.reload()
# Old settings did not change
assert_equal(res.status_code, http.BAD_REQUEST)
assert_equal(self.node_settings.dataverse_alias, 'ALIAS2')
assert_equal(self.node_settings.study, 'Example (DVN/00001)')
assert_equal(self.node_settings.study_hdl, 'doi:12.3456/DVN/00001')
# Nothing was logged
self.project.reload()
assert_equal(len(self.project.logs), num_old_logs)
def test_dataverse_root_not_published(self, mock_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_files.return_value = []
self.project.set_privacy('public')
self.project.save()
alias = self.node_settings.dataverse_alias
doi = self.node_settings.dataset_doi
external_account = create_external_account()
self.user.external_accounts.append(external_account)
self.user.save()
self.node_settings.set_auth(external_account, self.user)
self.node_settings.dataverse_alias = alias
self.node_settings.dataset_doi = doi
self.node_settings.save()
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
# Contributor gets draft, no options
res = self.app.get(url, auth=self.user.auth)
assert_true(res.json[0]['permissions']['edit'])
assert_false(res.json[0]['hasPublishedFiles'])
assert_equal(res.json[0]['version'], 'latest')
# Non-contributor gets nothing
user2 = AuthUserFactory()
res = self.app.get(url, auth=user2.auth)
assert_equal(res.json, [])
def test_dataverse_add_external_account_existing(self, mock_connection):
mock_connection.return_value = create_mock_connection()
host = 'myfakehost.data.verse'
token = 'dont-use-this-token-in-other-tests'
display_name = 'loaded_version'
# Save an existing version
external_account = ExternalAccount(
provider='dataverse',
provider_name='Dataverse',
display_name=display_name,
oauth_key=host,
oauth_secret=token,
provider_id=token,
)
external_account.save()
url = api_url_for('dataverse_add_user_account')
params = {'host': host, 'api_token': token}
self.app.post_json(url, params, auth=self.user.auth)
self.user.reload()
assert_equal(len(self.user.external_accounts), 1)
external_account = self.user.external_accounts[0]
assert_equal(external_account.provider, 'dataverse')
assert_equal(external_account.oauth_key, host)
assert_equal(external_account.oauth_secret, token)
# Ensure we got the loaded version
assert_equal(external_account.display_name, display_name)
def setUp(self):
super(TestDataverseSerializer, self).setUp()
self.ser = self.Serializer(user_settings=self.user_settings,
node_settings=self.node_settings)
self.mock_api = mock.patch(
'website.addons.dataverse.serializer.client.connect_from_settings')
self.mock_api.return_value = create_mock_connection()
self.mock_api.start()
def test_mock_connection(self):
mock_connection = create_mock_connection()
assert_equal(mock_connection.token, 'snowman-frosty')
assert_equal(len(mock_connection.get_dataverses()), 3)
assert_is_instance(mock_connection.get_dataverses()[0], Dataverse)
assert_equal(
mock_connection.get_dataverse(mock_connection.get_dataverses()[1].alias),
mock_connection.get_dataverses()[1],
)
def setUp(self):
super(TestDataverseSerializer, self).setUp()
self.ser = self.Serializer(
user_settings=self.user_settings,
node_settings=self.node_settings
)
self.mock_api = mock.patch('website.addons.dataverse.serializer.client.connect_from_settings')
self.mock_api.return_value = create_mock_connection()
self.mock_api.start()
def test_serialize_settings_helper_returns_dv_info(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = serialize_settings(self.node_settings, self.user)
assert_equal(len(result['dataverses']), 3)
assert_equal(result['savedDataverse']['title'], self.node_settings.dataverse)
assert_equal(result['savedDataverse']['alias'], self.node_settings.dataverse_alias)
assert_equal(result['savedStudy']['title'], self.node_settings.study)
assert_equal(result['savedStudy']['hdl'], self.node_settings.study_hdl)
def test_dataverse_publish_both(self, mock_publish_dv, mock_publish_ds, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_publish_dataset',
pid=self.project._primary_key)
self.app.put_json(url, params={'publish_both': True}, auth=self.user.auth)
# Both Dataverse and dataset were published
assert_true(mock_publish_dv.called)
assert_true(mock_publish_ds.called)
def test_dataverse_root_no_connection(self, mock_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_files.return_value = ['mock_file']
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
mock_connection.return_value = None
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_data_contents_no_connection(self, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
# If there is no connection, no files are returned
mock_connection.return_value = None
url = api_url_for('dataverse_hgrid_data_contents',
pid=self.project._primary_key)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_root_no_connection(self, mock_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_files.return_value = ['mock_file']
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
mock_connection.return_value = None
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_data_contents_no_connection(self, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
# If there is no connection, no files are returned
mock_connection.return_value = None
url = api_url_for('dataverse_hgrid_data_contents',
pid=self.project._primary_key)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_serialize_settings_helper_returns_dv_info(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = serialize_settings(self.node_settings, self.user)
assert_equal(len(result['dataverses']), 3)
assert_equal(result['savedDataverse']['title'], self.node_settings.dataverse)
assert_equal(result['savedDataverse']['alias'], self.node_settings.dataverse_alias)
assert_equal(result['savedDataset']['title'], self.node_settings.dataset)
assert_equal(result['savedDataset']['doi'], self.node_settings.dataset_doi)
def test_dataverse_data_contents_no_study(self, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
# If there is no study, no data are returned
self.node_settings.study_hdl = None
self.node_settings.save()
url = api_url_for('dataverse_hgrid_data_contents',
pid=self.project._primary_key)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_get_studies(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_get_studies', pid=self.project._primary_key)
params = {'alias': 'ALIAS1'}
res = self.app.post_json(url, params, auth=self.user.auth)
assert_equal(len(res.json['studies']), 3)
first = res.json['studies'][0]
assert_equal(first['title'], 'Example (DVN/00001)')
assert_equal(first['hdl'], 'doi:12.3456/DVN/00001')
def test_dataverse_data_contents_no_study(self, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
# If there is no study, no data are returned
self.node_settings.study_hdl = None
self.node_settings.save()
url = api_url_for('dataverse_hgrid_data_contents',
pid=self.project._primary_key)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_get_datasets(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_get_datasets', pid=self.project._primary_key)
params = {'alias': 'ALIAS1'}
res = self.app.post_json(url, params, auth=self.user.auth)
assert_equal(len(res.json['datasets']), 3)
first = res.json['datasets'][0]
assert_equal(first['title'], 'Example (DVN/00001)')
assert_equal(first['doi'], 'doi:12.3456/DVN/00001')
def test_user_config_get(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_user_config_get')
res = self.app.get(url, auth=self.user.auth)
result = res.json.get('result')
assert_true(result['connected'])
assert_true(result['userHasAuth'])
assert_equal(result['apiToken'], self.user_settings.api_token)
assert_in('create', result['urls'])
assert_in('delete', result['urls'])
def test_delete_file(self, mock_get, mock_delete, mock_connection):
mock_get.return_value = None
mock_connection.return_value = create_mock_connection()
path = '54321'
url = api_url_for('dataverse_delete_file',
pid=self.project._primary_key, path=path)
res = self.app.delete(url=url, auth=self.user.auth)
mock_delete.assert_called_once
assert_equal(path, mock_delete.call_args[0][0].id)
def test_delete_file(self, mock_get, mock_delete, mock_connection):
mock_get.return_value = None
mock_connection.return_value = create_mock_connection()
path = '54321'
url = api_url_for('dataverse_delete_file',
pid=self.project._primary_key, path=path)
self.app.delete(url=url, auth=self.user.auth)
mock_delete.assert_called_once()
assert_equal(path, mock_delete.call_args[0][0].id)
def test_dataverse_root_no_connection(self, mock_files, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
mock_request.args = {'state': 'released'}
mock_files.return_value = ['mock_file']
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
mock_connection.return_value = None
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_serialize_settings_helper_returns_dv_info(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = self.serializer.serialized_node_settings
assert_equal(len(result['dataverses']), 3)
assert_true(result['connected'])
assert_equal(result['dataverseHost'], self.host)
assert_equal(result['savedDataverse']['title'], self.node_settings.dataverse)
assert_equal(result['savedDataverse']['alias'], self.node_settings.dataverse_alias)
assert_equal(result['savedDataset']['title'], self.node_settings.dataset)
assert_equal(result['savedDataset']['doi'], self.node_settings.dataset_doi)
def test_dataverse_view_file(self, mock_fail_if_private, mock_get_files, mock_connection, mock_get_content, mock_scrape):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
mock_get_content.return_value = 'contents'
mock_scrape.return_value = ('filename', 'whatever')
url = self.project.web_url_for('dataverse_view_file', path='foo')
res = self.app.get(url, auth=self.user.auth).follow(auth=self.user.auth)
assert_true(mock_connection.called)
assert_true(mock_get_files.called)
assert_equal(res.status_code, 200)
def test_download_file(self, mock_fail_if_private, mock_get_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
path = 'foo'
url = web_url_for('dataverse_download_file',
pid=self.project._primary_key, path=path)
res = self.app.get(url, auth=self.user.auth)
assert_equal(
res.headers.get('location'),
'http://{0}/dvn/FileDownload/?fileId={1}'.format(HOST, path),
)
def test_dataverse_root_no_connection(self, mock_files, mock_request, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_request.referrer = 'some_url/files/'
mock_request.args = {'state': 'released'}
mock_files.return_value = ['mock_file']
url = api_url_for('dataverse_root_folder_public',
pid=self.project._primary_key)
mock_connection.return_value = None
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.json, [])
def test_dataverse_view_file(self, mock_fail_if_private, mock_get_files, mock_connection, mock_get_content, mock_scrape):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
mock_get_content.return_value = 'contents'
mock_scrape.return_value = ('filename', 'whatever')
url = self.project.web_url_for('dataverse_view_file', path='foo')
res = self.app.get(url, auth=self.user.auth).follow(auth=self.user.auth)
assert_true(mock_connection.called)
assert_true(mock_get_files.called)
assert_equal(res.status_code, 200)
def test_download_file(self, mock_fail_if_private, mock_get_files, mock_connection):
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
path = 'foo'
url = web_url_for('dataverse_download_file',
pid=self.project._primary_key, path=path)
res = self.app.get(url, auth=self.user.auth)
assert_equal(
res.headers.get('location'),
'http://{0}/dvn/FileDownload/?fileId={1}'.format(HOST, path),
)
def test_user_config_get(self, mock_connection):
mock_connection.return_value = create_mock_connection()
url = api_url_for('dataverse_user_config_get')
res = self.app.get(url, auth=self.user.auth)
result = res.json.get('result')
assert_true(result['connected'])
assert_true(result['userHasAuth'])
assert_equal(result['apiToken'], self.user_settings.api_token)
assert_in('create', result['urls'])
assert_in('delete', result['urls'])
def test_serialize_settings_helper_returns_correct_urls(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = serialize_settings(self.node_settings, self.user)
urls = result['urls']
assert_equal(urls['set'], self.project.api_url_for('set_dataverse_and_study'))
assert_equal(urls['importAuth'], self.project.api_url_for('dataverse_import_user_auth'))
assert_equal(urls['deauthorize'], self.project.api_url_for('deauthorize_dataverse'))
assert_equal(urls['getStudies'], self.project.api_url_for('dataverse_get_studies'))
assert_equal(urls['studyPrefix'], 'http://dx.doi.org/')
assert_equal(urls['dataversePrefix'], 'http://{0}/dvn/dv/'.format(HOST))
assert_equal(urls['owner'], web_url_for('profile_view_id', uid=self.user._primary_key))
def test_serialize_settings_helper_returns_correct_urls(self, mock_connection):
mock_connection.return_value = create_mock_connection()
result = serialize_settings(self.node_settings, self.user)
urls = result['urls']
assert_equal(urls['set'], self.project.api_url_for('set_dataverse_and_dataset'))
assert_equal(urls['importAuth'], self.project.api_url_for('dataverse_import_user_auth'))
assert_equal(urls['deauthorize'], self.project.api_url_for('deauthorize_dataverse'))
assert_equal(urls['getDatasets'], self.project.api_url_for('dataverse_get_datasets'))
assert_equal(urls['datasetPrefix'], 'http://dx.doi.org/')
assert_equal(urls['dataversePrefix'], 'http://{0}/dataverse/'.format(HOST))
assert_equal(urls['owner'], web_url_for('profile_view_id', uid=self.user._primary_key))
def test_dataverse_view_file_with_anonymous_link(self, mock_fail_if_private, mock_get_files, mock_connection, mock_scrape):
link = PrivateLinkFactory(anonymous=True)
link.nodes.append(self.project)
link.save()
mock_connection.return_value = create_mock_connection()
mock_get_files.return_value = [create_mock_draft_file('foo')]
mock_scrape.return_value = ('filename', 'content')
url = self.project.api_url_for('dataverse_get_file_info', path='foo')
res = self.app.get(url, {'view_only': link.key}).maybe_follow()
assert_equal(res.status_code, 200)
assert_not_in(self.node_settings.dataverse_alias, res.body)
assert_not_in(self.node_settings.dataverse, res.body)
assert_not_in(self.node_settings.study, res.body)
def test_serialize_settings_helper_returns_correct_urls(self, mock_connection):
mock_connection.return_value = create_mock_connection()
# result =
urls = self.serializer.serialized_urls
assert_equal(urls['create'], api_url_for('dataverse_add_user_account'))
assert_equal(urls['set'], self.project.api_url_for('dataverse_set_config'))
assert_equal(urls['importAuth'], self.project.api_url_for('dataverse_add_user_auth'))
assert_equal(urls['deauthorize'], self.project.api_url_for('dataverse_remove_user_auth'))
assert_equal(urls['getDatasets'], self.project.api_url_for('dataverse_get_datasets'))
assert_equal(urls['datasetPrefix'], 'http://dx.doi.org/')
assert_equal(urls['dataversePrefix'], 'http://{0}/dataverse/'.format(self.host))
assert_equal(urls['accounts'], api_url_for('dataverse_get_user_accounts'))
