CKAN-Extensions
/
ckanext-privatedatasets
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #8 from conwetlab/develop 

Fix minor typo
This commit is contained in:
Aitor Magán García 2014-08-28 15:59:41 +02:00
parent 122feb6b36 80165b5074
commit c7bfa3b036
18 changed files with 137 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ckanext/privatedatasets/actions.py
View File

@ -9,12 +9,12 @@ log = logging.getLogger(__name__)
PARSER_CONFIG_PROP = 'ckan.privatedatasets.parser'
def package_adquired(context, request_data):
def package_acquired(context, request_data):
log.info('Notification Request received')
# Check access
plugins.toolkit.check_access(constants.PACKAGE_ADQUIRED, context, request_data)
plugins.toolkit.check_access(constants.PACKAGE_ACQUIRED, context, request_data)
# Get the parser from the configuration
class_path = config.get(PARSER_CONFIG_PROP, '')

12
ckanext/privatedatasets/auth.py
View File

@ -41,15 +41,15 @@ def package_show(context, data_dict):
authorized = True
if not authorized:
# Show a flash message with the URL to adquire the dataset
# Show a flash message with the URL to acquire the dataset
# This message only can be shown when the user tries to access the dataset via its URL (/dataset/...)
# The message cannot be displayed in other pages that uses the package_show function such as
# the user profile page
if hasattr(package, 'extras') and 'adquire_url' in package.extras and request.path.startswith('/dataset/')\
and package.extras['adquire_url'] != '':
helpers.flash_notice(_('This private dataset can be adquired. To do so, please click ' +
'<a target="_blank" href="%s">here</a>') % package.extras['adquire_url'],
if hasattr(package, 'extras') and 'acquire_url' in package.extras and request.path.startswith('/dataset/')\
and package.extras['acquire_url'] != '':
helpers.flash_notice(_('This private dataset can be acquired. To do so, please click ' +
'<a target="_blank" href="%s">here</a>') % package.extras['acquire_url'],
allow_html=True)
return {'success': False, 'msg': _('User %s not authorized to read package %s') % (user, package.id)}
@ -111,6 +111,6 @@ def resource_show(context, data_dict):
@tk.auth_allow_anonymous_access
def package_adquired(context, data_dict):
def package_acquired(context, data_dict):
# TODO: Improve security
return {'success': True}

4
ckanext/privatedatasets/constants.py
View File

@ -1,6 +1,6 @@
ALLOWED_USERS = 'allowed_users'
ALLOWED_USERS_STR = 'allowed_users_str'
SEARCHABLE = 'searchable'
ADQUIRE_URL = 'adquire_url'
ACQUIRE_URL = 'acquire_url'
CONTEXT_CALLBACK = 'updating_via_cb'
PACKAGE_ADQUIRED = 'package_adquired'
PACKAGE_ACQUIRED = 'package_acquired'

12
ckanext/privatedatasets/controllers/ui_controller.py
View File

@ -9,9 +9,9 @@ from ckan.common import _
log = logging.getLogger(__name__)
class AdquiredDatasetsControllerUI(base.BaseController):
class AcquiredDatasetsControllerUI(base.BaseController):
def user_adquired_datasets(self):
def user_acquired_datasets(self):
db.init_db(model)
@ -25,13 +25,13 @@ class AdquiredDatasetsControllerUI(base.BaseController):
# Get user information
try:
c.user_dict = plugins.toolkit.get_action('user_show')(context.copy(), {'user_obj': c.userobj})
c.user_dict['adquired_datasets'] = []
c.user_dict['acquired_datasets'] = []
except plugins.toolkit.ObjectNotFound:
plugins.toolkit.abort(404, _('User not found'))
except plugins.toolkit.NotAuthorized:
plugins.toolkit.abort(401, _('Not authorized to see this page'))
# Get the datasets adquired by the user
# Get the datasets acquired by the user
query = db.AllowedUser.get(user_name=context['user'])
# Get the datasets
@ -40,8 +40,8 @@ class AdquiredDatasetsControllerUI(base.BaseController):
dataset_dict = plugins.toolkit.get_action('package_show')(context.copy(), {'id': dataset.package_id})
# Only packages with state == 'active' can be shown
if dataset_dict.get('state', None) == 'active':
c.user_dict['adquired_datasets'].append(dataset_dict)
c.user_dict['acquired_datasets'].append(dataset_dict)
except Exception:
continue
return plugins.toolkit.render('user/dashboard_adquired.html')
return plugins.toolkit.render('user/dashboard_acquired.html')

10
ckanext/privatedatasets/fanstatic/allowed_users.js
View File

@ -1,5 +1,5 @@
/* Dataset allowed_users, searchable and adquire_url toggler
* allowed_users, adquire_url and searchable can only be active when a
/* Dataset allowed_users, searchable and acquire_url toggler
* allowed_users, acquire_url and searchable can only be active when a
* user attempts to create a private dataset
*/
@ -14,16 +14,16 @@ this.ckan.module('allowed-users', function ($, _) {
if (ds_private == 'True') {
$('#field-allowed_users_str').prop('disabled', false); //Enable
$('#field-adquire_url').prop('disabled', false); //Enable
$('#field-acquire_url').prop('disabled', false); //Enable
$('#field-searchable').prop('disabled', false); //Enable
} else {
$('#field-allowed_users_str').prop('disabled', true); //Disable
$('#field-adquire_url').prop('disabled', true); //Disable
$('#field-acquire_url').prop('disabled', true); //Disable
$('#field-searchable').prop('disabled', true); //Disable
//Remove previous values
$('#field-allowed_users_str').select2('val', '');
$('#field-adquire_url').val('');
$('#field-acquire_url').val('');
$('#field-searchable').val('True');
}
}

2
ckanext/privatedatasets/fanstatic/custom.css
View File

@ -1,4 +1,4 @@
.label-adquired {
.label-acquired {
background-color: #55a1ce;
}

2
ckanext/privatedatasets/helpers.py
View File

@ -3,7 +3,7 @@ import ckan.plugins.toolkit as tk
import db
def is_dataset_adquired(pkg_dict):
def is_dataset_acquired(pkg_dict):
db.init_db(model)

22
ckanext/privatedatasets/plugin.py
View File

@ -36,7 +36,7 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
constants.ALLOWED_USERS: [conv_val.allowed_users_convert,
tk.get_validator('ignore_missing'),
conv_val.private_datasets_metadata_checker],
constants.ADQUIRE_URL: [tk.get_validator('ignore_missing'),
constants.ACQUIRE_URL: [tk.get_validator('ignore_missing'),
conv_val.private_datasets_metadata_checker,
conv_val.url_checker,
tk.get_converter('convert_to_extras')],
@ -63,7 +63,7 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
schema.update({
constants.ALLOWED_USERS: [conv_val.get_allowed_users,
tk.get_validator('ignore_missing')],
constants.ADQUIRE_URL: [tk.get_converter('convert_from_extras'),
constants.ACQUIRE_URL: [tk.get_converter('convert_from_extras'),
tk.get_validator('ignore_missing')],
constants.SEARCHABLE: [tk.get_converter('convert_from_extras'),
tk.get_validator('ignore_missing')]
@ -88,7 +88,7 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
return {'package_show': auth.package_show,
'package_update': auth.package_update,
'resource_show': auth.resource_show,
constants.PACKAGE_ADQUIRED: auth.package_adquired}
constants.PACKAGE_ACQUIRED: auth.package_acquired}
######################################################################
############################ ICONFIGURER #############################
@ -107,10 +107,10 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
######################################################################
def before_map(self, m):
# DataSet adquired notification
m.connect('user_adquired_datasets', '/dashboard/adquired', ckan_icon='shopping-cart',
controller='ckanext.privatedatasets.controllers.ui_controller:AdquiredDatasetsControllerUI',
action='user_adquired_datasets', conditions=dict(method=['GET']))
# DataSet acquired notification
m.connect('user_acquired_datasets', '/dashboard/acquired', ckan_icon='shopping-cart',
controller='ckanext.privatedatasets.controllers.ui_controller:AcquiredDatasetsControllerUI',
action='user_acquired_datasets', conditions=dict(method=['GET']))
return m
@ -119,7 +119,7 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
######################################################################
def get_actions(self):
return {constants.PACKAGE_ADQUIRED: actions.package_adquired}
return {constants.PACKAGE_ACQUIRED: actions.package_acquired}
######################################################################
######################### IPACKAGECONTROLLER #########################
@ -191,12 +191,12 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
user_obj = context.get('auth_user_obj')
updating_via_api = context.get(constants.CONTEXT_CALLBACK, False)
# allowed_users, searchable and adquire_url fileds can be only viewed by:
# allowed_users, searchable and acquire_url fileds can be only viewed by:
# * the dataset creator
# * the sysadmin
# * users allowed to update the allowed_users list via the notification API
if not updating_via_api and (not user_obj or (pkg_dict['creator_user_id'] != user_obj.id and not user_obj.sysadmin)):
attrs = [constants.ALLOWED_USERS, constants.SEARCHABLE, constants.ADQUIRE_URL]
attrs = [constants.ALLOWED_USERS, constants.SEARCHABLE, constants.ACQUIRE_URL]
for attr in attrs:
if attr in pkg_dict:
del pkg_dict[attr]
@ -223,7 +223,7 @@ class PrivateDatasets(p.SingletonPlugin, tk.DefaultDatasetForm):
######################################################################
def get_helpers(self):
return {'is_dataset_adquired': helpers.is_dataset_adquired,
return {'is_dataset_acquired': helpers.is_dataset_acquired,
'get_allowed_users_str': helpers.get_allowed_users_str,
'is_owner': helpers.is_owner,
'can_read': helpers.can_read}

2
ckanext/privatedatasets/templates/package/snippets/package_basic_fields.html
View File

@ -85,7 +85,7 @@
{% set users_attrs = {'data-module': 'autocomplete', 'data-module-tags': '', 'data-module-source': '/api/2/util/user/autocomplete?q=?'} %}
{{ form.input('allowed_users_str', label=_('Allowed Users'), id='field-allowed_users_str', placeholder=_('Allowed Users'), value=h.get_allowed_users_str(data.allowed_users), error=errors.custom_text, classes=['control-full'], attrs=users_attrs) }}
{{ form.input('adquire_url', label=_('Adquire URL'), id='field-adquire_url', placeholder=_('http://example.com/adquire/'), value=data.adquire_url, error=errors.custom_text, classes=['control-medium']) }}
{{ form.input('acquire_url', label=_('Acquire URL'), id='field-acquire_url', placeholder=_('http://example.com/acquire/'), value=data.acquire_url, error=errors.custom_text, classes=['control-medium']) }}
{% if data.id and h.check_access('package_delete', {'id': data.id}) and data.state != 'active' %}
<div class="control-group">

8
ckanext/privatedatasets/templates/snippets/package_item.html
View File

@ -17,7 +17,7 @@ Example:
{% set truncate_title = truncate_title or 80 %}
{% set title = package.title or package.name %}
{% set notes = h.markdown_extract(package.notes, extract_length=truncate) %}
{% set adquired = h.is_dataset_adquired(package) %}
{% set acquired = h.is_dataset_acquired(package) %}
{% set owner = h.is_owner(package) %}
{% resource 'privatedatasets/custom.css' %}
@ -32,10 +32,10 @@ Example:
{{ _('Private') }}
</span>
{% endif %}
{% if adquired and not owner %}
<span class="dataset-private label label-adquired">
{% if acquired and not owner %}
<span class="dataset-private label label-acquired">
<i class="icon-shopping-cart"></i>
{{ _('Adquired') }}
{{ _('Acquired') }}
</span>
{% endif %}
{% if owner %}

2
ckanext/privatedatasets/templates/user/dashboard.html
View File

@ -18,7 +18,7 @@
<ul class="nav nav-tabs">
{{ h.build_nav_icon('user_dashboard', _('News feed')) }}
{{ h.build_nav_icon('user_dashboard_datasets', _('My Datasets')) }}
{{ h.build_nav_icon('user_adquired_datasets', _('Adquired Datasets')) }}
{{ h.build_nav_icon('user_acquired_datasets', _('Acquired Datasets')) }}
{{ h.build_nav_icon('user_dashboard_organizations', _('My Organizations')) }}
{{ h.build_nav_icon('user_dashboard_groups', _('My Groups')) }}
</ul>

12
ckanext/privatedatasets/templates/user/dashboard_adquired.html → ckanext/privatedatasets/templates/user/dashboard_acquired.html
View File

@ -3,17 +3,17 @@
{% block dashboard_activity_stream_context %}{% endblock %}
{% block page_primary_action %}
{% link_for _('Adquire Dataset'), controller='package', action='search', class_="btn btn-primary", icon="shopping-cart" %}
{% link_for _('Acquire Dataset'), controller='package', action='search', class_="btn btn-primary", icon="shopping-cart" %}
{% endblock %}
{% block primary_content_inner %}
<h2 class="hide-heading">{{ _('Adquired Datasets') }}</h2>
{% if c.user_dict.adquired_datasets %}
{% snippet 'snippets/package_list.html', packages=c.user_dict.adquired_datasets %}
<h2 class="hide-heading">{{ _('Acquired Datasets') }}</h2>
{% if c.user_dict.acquired_datasets %}
{% snippet 'snippets/package_list.html', packages=c.user_dict.acquired_datasets %}
{% else %}
<p class="empty">
{{ _('You haven\'t adquired any datasets.') }}
{% link_for _('Adquire one now?'), controller='package', action='search' %}
{{ _('You haven\'t acquired any datasets.') }}
{% link_for _('Acquire one now?'), controller='package', action='search' %}
</p>
{% endif %}
{% endblock %}

8
ckanext/privatedatasets/tests/test_actions.py
View File

@ -60,11 +60,11 @@ class ActionsTest(unittest.TestCase):
# Call the function
if expected_error:
with self.assertRaises(actions.plugins.toolkit.ValidationError) as cm:
actions.package_adquired({}, {})
actions.package_acquired({}, {})
self.assertEqual(cm.exception.error_dict['message'], expected_error)
else:
# Exception is not risen
self.assertEquals(None, actions.package_adquired({}, {}))
self.assertEquals(None, actions.package_acquired({}, {}))
# Checks
self.assertEquals(0, actions.plugins.toolkit.get_action.call_count)
@ -142,7 +142,7 @@ class ActionsTest(unittest.TestCase):
# Call the function
context = {'user': 'user1', 'model': 'model', 'auth_obj': {'id': 1}}
result = actions.package_adquired(context, users_info)
result = actions.package_acquired(context, users_info)
# Calculate the list of warns
warns = []
@ -161,7 +161,7 @@ class ActionsTest(unittest.TestCase):
# Check that the initial functions (check_access and parse_notification) has been called properly
parse_notification.assert_called_once_with(users_info)
actions.plugins.toolkit.check_access.assert_called_once_with('package_adquired', context, users_info)
actions.plugins.toolkit.check_access.assert_called_once_with('package_acquired', context, users_info)
for user_datasets in parse_result['users_datasets']:
for dataset_id in user_datasets['datasets']:

12
ckanext/privatedatasets/tests/test_auth.py
View File

@ -41,7 +41,7 @@ class AuthTest(unittest.TestCase):
def test_decordators(self):
self.assertEquals(True, getattr(auth.package_show, 'auth_allow_anonymous_access', False))
self.assertEquals(True, getattr(auth.resource_show, 'auth_allow_anonymous_access', False))
self.assertEquals(True, getattr(auth.package_adquired, 'auth_allow_anonymous_access', False))
self.assertEquals(True, getattr(auth.package_acquired, 'auth_allow_anonymous_access', False))
@parameterized.expand([
# Anonymous user (public)
@ -80,7 +80,7 @@ class AuthTest(unittest.TestCase):
(1, 2, 'test', True, 'active', 'conwet', False, False, 'google.es', '/dataset/testds', False),
(1, 2, 'test', True, 'active', 'conwet', False, False, 'google.es', '/', False) ])
def test_auth_package_show(self, creator_user_id, user_obj_id, user, private, state, owner_org,
owner_member, db_auth, adquire_url, request_path, authorized):
owner_member, db_auth, acquire_url, request_path, authorized):
# Configure the mocks
returned_package = MagicMock()
@ -100,8 +100,8 @@ class AuthTest(unittest.TestCase):
auth.db.AllowedUser.get = MagicMock(return_value=db_response)
if adquire_url:
returned_package.extras['adquire_url'] = adquire_url
if acquire_url:
returned_package.extras['acquire_url'] = acquire_url
auth.logic_auth.get_package_object = MagicMock(return_value=returned_package)
auth.new_authz.has_user_permission_for_group_or_org = MagicMock(return_value=owner_member)
@ -229,5 +229,5 @@ class AuthTest(unittest.TestCase):
result = auth.resource_show(context, {})
self.assertEquals(authorized_pkg, result['success'])
def test_package_adquired(self):
self.assertTrue(auth.package_adquired({}, {}))
def test_package_acquired(self):
self.assertTrue(auth.package_acquired({}, {}))

12
ckanext/privatedatasets/tests/test_controller_ui.py
View File

@ -10,7 +10,7 @@ class UIControllerTest(unittest.TestCase):
def setUp(self):
# Get the instance
self.instanceUI = controller.AdquiredDatasetsControllerUI()
self.instanceUI = controller.AcquiredDatasetsControllerUI()
# Load the mocks
self._plugins = controller.plugins
@ -43,7 +43,7 @@ class UIControllerTest(unittest.TestCase):
controller.plugins.toolkit.get_action = MagicMock(return_value=user_show)
# Call the function
self.instanceUI.user_adquired_datasets()
self.instanceUI.user_acquired_datasets()
# Assertations
expected_context = {
@ -106,7 +106,7 @@ class UIControllerTest(unittest.TestCase):
controller.db.AllowedUser.get = MagicMock(return_value=query_res)
# Call the function
returned = self.instanceUI.user_adquired_datasets()
returned = self.instanceUI.user_acquired_datasets()
# Check that the database has been initialized properly
controller.db.init_db.assert_called_once_with(controller.model)
@ -130,16 +130,16 @@ class UIControllerTest(unittest.TestCase):
# Check that the template receives the correct datasets
expected_user_dict = user_dict.copy()
expected_user_dict['adquired_datasets'] = []
expected_user_dict['acquired_datasets'] = []
for i in pkgs_ids:
if i not in package_errors and i not in deleted_packages:
pkg = default_package.copy()
pkg['pkg_id'] = i
pkg['state'] = 'deleted' if i in deleted_packages else 'active'
expected_user_dict['adquired_datasets'].append(pkg)
expected_user_dict['acquired_datasets'].append(pkg)
self.assertEquals(expected_user_dict, controller.plugins.toolkit.c.user_dict)
# Check that the render method has been called and that its result has been returned
self.assertEquals(controller.plugins.toolkit.render.return_value, returned)
controller.plugins.toolkit.render.assert_called_once_with('user/dashboard_adquired.html')
controller.plugins.toolkit.render.assert_called_once_with('user/dashboard_acquired.html')

6
ckanext/privatedatasets/tests/test_helpers.py
View File

@ -29,13 +29,13 @@ class HelpersTest(unittest.TestCase):
(False, None, False),
(True, None, False),
])
def test_is_dataset_adquired(self, db_adquired, user, adquired):
def test_is_dataset_acquired(self, db_acquired, user, acquired):
# Configure test
helpers.tk.c.user = user
pkg_dict = {'id': 'package_id'}
db_response = []
if db_adquired is True:
if db_acquired is True:
out = helpers.db.AllowedUser()
out.package_id = 'package_id'
out.user_name = user
@ -44,7 +44,7 @@ class HelpersTest(unittest.TestCase):
helpers.db.AllowedUser.get = MagicMock(return_value=db_response)
# Check the function returns the expected result
self.assertEquals(adquired, helpers.is_dataset_adquired(pkg_dict))
self.assertEquals(acquired, helpers.is_dataset_acquired(pkg_dict))
# Check that the database has been initialized properly
helpers.db.init_db.assert_called_once_with(helpers.model)

22
ckanext/privatedatasets/tests/test_plugin.py
View File

@ -42,7 +42,7 @@ class PluginTest(unittest.TestCase):
('package_show', plugin.auth.package_show),
('package_update', plugin.auth.package_update),
('package_show', plugin.auth.package_show),
('package_adquired', plugin.auth.package_adquired)
('package_acquired', plugin.auth.package_acquired)
])
def test_auth_function(self, function_name, expected_function):
auth_functions = self.privateDatasets.get_auth_functions()
@ -63,12 +63,12 @@ class PluginTest(unittest.TestCase):
self.privateDatasets.before_map(m)
# Test that the connect method has been called
m.connect.assert_any_call('user_adquired_datasets', '/dashboard/adquired', ckan_icon='shopping-cart',
controller='ckanext.privatedatasets.controllers.ui_controller:AdquiredDatasetsControllerUI',
action='user_adquired_datasets', conditions=dict(method=['GET']))
m.connect.assert_any_call('user_acquired_datasets', '/dashboard/acquired', ckan_icon='shopping-cart',
controller='ckanext.privatedatasets.controllers.ui_controller:AcquiredDatasetsControllerUI',
action='user_acquired_datasets', conditions=dict(method=['GET']))
@parameterized.expand([
('package_adquired', plugin.actions.package_adquired)
('package_acquired', plugin.actions.package_acquired)
])
def test_actions_function(self, function_name, expected_function):
actions = self.privateDatasets.get_actions()
@ -81,7 +81,7 @@ class PluginTest(unittest.TestCase):
self.assertEquals([], self.privateDatasets.package_types())
@parameterized.expand([
('is_dataset_adquired', plugin.helpers.is_dataset_adquired),
('is_dataset_acquired', plugin.helpers.is_dataset_acquired),
('get_allowed_users_str', plugin.helpers.get_allowed_users_str),
('is_owner', plugin.helpers.is_owner),
('can_read', plugin.helpers.can_read)
@ -111,7 +111,7 @@ class PluginTest(unittest.TestCase):
fields = {
'private': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_validator('boolean_validator')],
'adquire_url': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_converter('convert_to_extras'),
'acquire_url': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_converter('convert_to_extras'),
plugin.conv_val.url_checker, plugin.conv_val.private_datasets_metadata_checker],
'searchable': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_validator('boolean_validator'),
plugin.tk.get_converter('convert_to_extras'), plugin.conv_val.private_datasets_metadata_checker],
@ -126,10 +126,10 @@ class PluginTest(unittest.TestCase):
returned_schema = self.privateDatasets.show_package_schema()
fields = ['searchable', 'adquire_url']
fields = ['searchable', 'acquire_url']
fields = {
'adquire_url': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_converter('convert_from_extras')],
'acquire_url': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_converter('convert_from_extras')],
'searchable': [plugin.tk.get_validator('ignore_missing'), plugin.tk.get_converter('convert_from_extras')],
'allowed_users': [plugin.tk.get_validator('ignore_missing'), plugin.conv_val.get_allowed_users]
}
@ -212,13 +212,13 @@ class PluginTest(unittest.TestCase):
user.sysadmin = sysadmin
context['auth_user_obj'] = user
pkg_dict = {'creator_user_id': creator_id, 'allowed_users': ['a', 'b', 'c'], 'searchable': True, 'adquire_url': 'http://google.es'}
pkg_dict = {'creator_user_id': creator_id, 'allowed_users': ['a', 'b', 'c'], 'searchable': True, 'acquire_url': 'http://google.es'}
# Call the function
result = self.privateDatasets.after_show(context, pkg_dict) # Call the function
# Check the final result
fields = ['allowed_users', 'searchable', 'adquire_url']
fields = ['allowed_users', 'searchable', 'acquire_url']
for field in fields:
if fields_expected:
self.assertTrue(field in result)

122
ckanext/privatedatasets/tests/test_selenium.py
View File

@ -110,7 +110,7 @@ class TestSelenium(unittest.TestCase):
driver.find_element_by_id('username').send_keys(user)
driver.find_element_by_name('submit').click()
def create_ds_first_page(self, name, description, tags, private, searchable, allowed_users, adquire_url):
def create_ds_first_page(self, name, description, tags, private, searchable, allowed_users, acquire_url):
# FIRST PAGE: Dataset properties
driver = self.driver
driver.get(self.base_url)
@ -131,17 +131,17 @@ class TestSelenium(unittest.TestCase):
Select(driver.find_element_by_id('field-searchable')).select_by_visible_text('True' if searchable else 'False')
driver.find_element_by_id('field-allowed_users_str').clear()
driver.find_element_by_id('field-allowed_users_str').send_keys(','.join(allowed_users))
driver.find_element_by_id('field-adquire_url').clear()
if adquire_url:
driver.find_element_by_id('field-adquire_url').send_keys(adquire_url)
driver.find_element_by_id('field-acquire_url').clear()
if acquire_url:
driver.find_element_by_id('field-acquire_url').send_keys(acquire_url)
else:
self.assert_fields_disabled(['field-searchable', 'field-allowed_users_str', 'field-adquire_url'])
self.assert_fields_disabled(['field-searchable', 'field-allowed_users_str', 'field-acquire_url'])
driver.find_element_by_name('save').click()
def create_ds(self, name, description, tags, private, searchable, allowed_users, adquire_url, resource_url, resource_name, resource_description, resource_format):
def create_ds(self, name, description, tags, private, searchable, allowed_users, acquire_url, resource_url, resource_name, resource_description, resource_format):
driver = self.driver
self.create_ds_first_page(name, description, tags, private, searchable, allowed_users, adquire_url)
self.create_ds_first_page(name, description, tags, private, searchable, allowed_users, acquire_url)
# SECOND PAGE: Add Resources
try:
@ -162,14 +162,14 @@ class TestSelenium(unittest.TestCase):
driver.find_element_by_xpath('(//button[@name=\'save\'])[4]').click()
driver.find_element_by_xpath('(//button[@name=\'save\'])[4]').click()
def check_ds_values(self, url, private, searchable, allowed_users, adquire_url):
def check_ds_values(self, url, private, searchable, allowed_users, acquire_url):
driver = self.driver
driver.get(self.base_url + 'dataset/edit/' + url)
self.assertEqual('Private' if private else 'Public', Select(driver.find_element_by_id('field-private')).first_selected_option.text)
if private:
adquire_url_final = '' if adquire_url is None else adquire_url
self.assertEqual(adquire_url_final, driver.find_element_by_id('field-adquire_url').get_attribute('value'))
acquire_url_final = '' if acquire_url is None else acquire_url
self.assertEqual(acquire_url_final, driver.find_element_by_id('field-acquire_url').get_attribute('value'))
self.assertEqual('True' if searchable else 'False', Select(driver.find_element_by_id('field-searchable')).first_selected_option.text)
# Test that the allowed users lists is as expected (order is not important)
@ -182,9 +182,9 @@ class TestSelenium(unittest.TestCase):
for user in current_users:
self.assertIn(user, allowed_users)
else:
self.assert_fields_disabled(['field-searchable', 'field-allowed_users_str', 'field-adquire_url'])
self.assert_fields_disabled(['field-searchable', 'field-allowed_users_str', 'field-acquire_url'])
def check_user_access(self, dataset, dataset_url, owner, adquired, in_org, private, searchable, adquire_url=None):
def check_user_access(self, dataset, dataset_url, owner, acquired, in_org, private, searchable, acquire_url=None):
driver = self.driver
driver.find_element_by_link_text('Datasets').click()
@ -192,10 +192,10 @@ class TestSelenium(unittest.TestCase):
xpath = '//div[@id=\'content\']/div[3]/div/section/div/ul/li/div/h3/span'
# Check the label
if not adquired and private and not in_org:
if not acquired and private and not in_org:
self.assertEqual('PRIVATE', driver.find_element_by_xpath(xpath).text)
elif adquired and not owner and private:
self.assertEqual('ADQUIRED', driver.find_element_by_xpath(xpath).text)
elif acquired and not owner and private:
self.assertEqual('ACQUIRED', driver.find_element_by_xpath(xpath).text)
elif owner:
self.assertEqual('OWNER', driver.find_element_by_xpath(xpath).text)
@ -209,12 +209,12 @@ class TestSelenium(unittest.TestCase):
# Access the dataset
driver.get(self.base_url + 'dataset/' + dataset_url)
if not adquired and private and not in_org:
if not acquired and private and not in_org:
xpath = '//div[@id=\'content\']/div/div'
buy_msg = 'This private dataset can be adquired. To do so, please click here'
if adquire_url is not None:
buy_msg = 'This private dataset can be acquired. To do so, please click here'
if acquire_url is not None:
self.assertTrue(driver.find_element_by_xpath(xpath).text.startswith(buy_msg))
self.assertEquals(adquire_url, driver.find_element_by_link_text('here').get_attribute('href'))
self.assertEquals(acquire_url, driver.find_element_by_link_text('here').get_attribute('href'))
xpath += '[2]' # The unauthorized message is in a different Path
else:
src = driver.page_source
@ -226,22 +226,22 @@ class TestSelenium(unittest.TestCase):
else:
self.assertEquals(self.base_url + 'dataset/%s' % dataset_url, driver.current_url)
def check_adquired(self, dataset, dataset_url, adquired, private):
def check_acquired(self, dataset, dataset_url, acquired, private):
driver = self.driver
driver.get(self.base_url + 'dashboard')
driver.find_element_by_link_text('Adquired Datasets').click()
driver.find_element_by_link_text('Acquired Datasets').click()
if adquired and private:
# This message could not be shown when the user has adquired at least one dataset
self.assertEquals(None, re.search('You haven\'t adquired any datasets.', driver.page_source))
if acquired and private:
# This message could not be shown when the user has acquired at least one dataset
self.assertEquals(None, re.search('You haven\'t acquired any datasets.', driver.page_source))
# Access the dataset
driver.find_element_by_link_text(dataset).click()
self.assertEquals(self.base_url + 'dataset/%s' % dataset_url, driver.current_url)
else:
# If the user has not adquired the dataset, a link to this dataset could not be in the adquired dataset list
# If the user has not acquired the dataset, a link to this dataset could not be in the acquired dataset list
self.assertEquals(None, re.search(dataset_url, driver.page_source))
# When a user has not adquired any dataset, a message will be shown to inform the user
self.assertNotEquals(None, re.search('You haven\'t adquired any datasets.', driver.page_source))
# When a user has not acquired any dataset, a message will be shown to inform the user
self.assertNotEquals(None, re.search('You haven\'t acquired any datasets.', driver.page_source))
def default_register(self, user):
self.register(user, user, '%s@conwet.com' % user, user)
@ -260,7 +260,7 @@ class TestSelenium(unittest.TestCase):
(['user1', 'user2', 'user3', 'user4'], False, True, ['user3', 'user4']),
(['user1', 'user2', 'user3', 'user4'], True, False, ['user2', 'user4']),
])
def test_basic(self, users, private, searchable, allowed_users, adquire_url=None):
def test_basic(self, users, private, searchable, allowed_users, acquire_url=None):
# Create users
for user in users:
self.default_register(user)
@ -270,19 +270,19 @@ class TestSelenium(unittest.TestCase):
pkg_name = 'Dataset 1'
url = get_dataset_url(pkg_name)
self.create_ds(pkg_name, 'Example description', ['tag1', 'tag2', 'tag3'], private, searchable,
allowed_users, adquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
self.check_ds_values(url, private, searchable, allowed_users, adquire_url)
self.check_user_access(pkg_name, url, True, True, False, private, searchable, adquire_url)
self.check_adquired(pkg_name, url, False, private)
allowed_users, acquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
self.check_ds_values(url, private, searchable, allowed_users, acquire_url)
self.check_user_access(pkg_name, url, True, True, False, private, searchable, acquire_url)
self.check_acquired(pkg_name, url, False, private)
# Rest of users
rest_users = users[1:]
for user in rest_users:
self.logout()
self.login(user, user)
adquired = user in allowed_users
self.check_user_access(pkg_name, url, False, adquired, False, private, searchable, adquire_url)
self.check_adquired(pkg_name, url, adquired, private)
acquired = user in allowed_users
self.check_user_access(pkg_name, url, False, acquired, False, private, searchable, acquire_url)
self.check_acquired(pkg_name, url, acquired, private)
@parameterized.expand([
# (['a'] , 'http://upm.es', 'Allowed users: Name must be at least 2 characters long'),
@ -292,17 +292,17 @@ class TestSelenium(unittest.TestCase):
(['upm', 'a?-vz'], 'http://upm.es', 'Allowed users: Url must be purely lowercase alphanumeric (ascii) characters and these symbols: -_'),
(['thisisaveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryveryverylongname'],
'http://upm.es', 'Allowed users: Name must be a maximum of 100 characters long'),
(['conwet'], 'ftp://google.es', 'Adquire URL: The URL "ftp://google.es" is not valid.'),
# (['conwet'], 'http://google*.com', 'Adquire URL: The URL "http://google*.com" is not valid.'),
# (['conwet'], 'http://google+.com', 'Adquire URL: The URL "http://google+.com" is not valid.'),
# (['conwet'], 'http://google/.com', 'Adquire URL: The URL "http://google/.com" is not valid.'),
(['conwet'], 'google', 'Adquire URL: The URL "google" is not valid.'),
(['conwet'], 'http://google', 'Adquire URL: The URL "http://google" is not valid.'),
# (['conwet'], 'http://google:es', 'Adquire URL: The URL "http://google:es" is not valid.'),
(['conwet'], 'www.google.es', 'Adquire URL: The URL "www.google.es" is not valid.')
(['conwet'], 'ftp://google.es', 'Acquire URL: The URL "ftp://google.es" is not valid.'),
# (['conwet'], 'http://google*.com', 'Acquire URL: The URL "http://google*.com" is not valid.'),
# (['conwet'], 'http://google+.com', 'Acquire URL: The URL "http://google+.com" is not valid.'),
# (['conwet'], 'http://google/.com', 'Acquire URL: The URL "http://google/.com" is not valid.'),
(['conwet'], 'google', 'Acquire URL: The URL "google" is not valid.'),
(['conwet'], 'http://google', 'Acquire URL: The URL "http://google" is not valid.'),
# (['conwet'], 'http://google:es', 'Acquire URL: The URL "http://google:es" is not valid.'),
(['conwet'], 'www.google.es', 'Acquire URL: The URL "www.google.es" is not valid.')
])
def test_invalid_fields(self, allowed_users, adquire_url, expected_msg):
def test_invalid_fields(self, allowed_users, acquire_url, expected_msg):
# Create a default user
user = 'user1'
self.default_register(user)
@ -310,15 +310,15 @@ class TestSelenium(unittest.TestCase):
# Create the dataset
self.login(user, user)
pkg_name = 'Dataset 2'
self.create_ds_first_page(pkg_name, 'Example description', ['tag1'], True, True, allowed_users, adquire_url)
self.create_ds_first_page(pkg_name, 'Example description', ['tag1'], True, True, allowed_users, acquire_url)
# Check the error message
msg_error = self.driver.find_element_by_xpath('//div[@id=\'content\']/div[3]/div/section/div/form/div/ul/li').text
self.assertEquals(expected_msg, msg_error)
@parameterized.expand([
('Adquire Dataset', 'dataset'),
('Adquire one now?', 'dataset')
('Acquire Dataset', 'dataset'),
('Acquire one now?', 'dataset')
])
def test_dashboard_basic_links(self, link, expected_url):
# Create a default user
@ -326,9 +326,9 @@ class TestSelenium(unittest.TestCase):
self.default_register(user)
self.login(user, user)
# Enter the adquired dataset tab
# Enter the acquired dataset tab
driver = self.driver
driver.get(self.base_url + 'dashboard/adquired')
driver.get(self.base_url + 'dashboard/acquired')
driver.find_element_by_link_text(link).click()
self.assertEquals(self.base_url + 'dataset', self.base_url + expected_url)
@ -369,14 +369,14 @@ class TestSelenium(unittest.TestCase):
self.default_register(user)
self.login(user, user)
adquire_url = 'http://upm.es'
acquire_url = 'http://upm.es'
dataset_default_name = 'Dataset %d'
# Create the dataset
for i, dataset in enumerate(datasets):
pkg_name = dataset_default_name % i
self.create_ds(pkg_name, 'Example description', ['tag1'], dataset['private'], dataset['searchable'],
dataset['allowed_users'], adquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
dataset['allowed_users'], acquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
# Make the requests
for user in users_via_api:
@ -386,7 +386,7 @@ class TestSelenium(unittest.TestCase):
resources.append({'url': self.base_url + 'dataset/' + get_dataset_url(dataset_default_name % i)})
content = {'customer_name': user, 'resources': resources}
req = requests.post(self.base_url + 'api/action/package_adquired', data=json.dumps(content),
req = requests.post(self.base_url + 'api/action/package_acquired', data=json.dumps(content),
headers={'content-type': 'application/json'})
result = json.loads(req.text)['result']
@ -405,7 +405,7 @@ class TestSelenium(unittest.TestCase):
final_users = []
url_path = get_dataset_url(dataset_default_name % i)
self.check_ds_values(url_path, dataset['private'], dataset['searchable'], final_users, adquire_url)
self.check_ds_values(url_path, dataset['private'], dataset['searchable'], final_users, acquire_url)
@parameterized.expand([
# (['user1', 'user2', 'user3'], [{'name': 'CoNWeT', 'users': ['user2']}], True, True, [], 'http://store.conwet.com/'),
@ -433,7 +433,7 @@ class TestSelenium(unittest.TestCase):
(['user1', 'user2', 'user3', 'user4', 'user5', 'user6'], [{'name': 'CoNWeT', 'users': ['user2', 'user3']},
{'name': 'UPM', 'users': ['user6']}], False, True, ['user4', 'user5']),
])
def test_organization(self, users, orgs, private, searchable, adquiring_users, adquire_url=None):
def test_organization(self, users, orgs, private, searchable, adquiring_users, acquire_url=None):
# Create users
for user in users:
self.default_register(user)
@ -448,17 +448,17 @@ class TestSelenium(unittest.TestCase):
pkg_name = 'Dataset 1'
url = get_dataset_url(pkg_name)
self.create_ds(pkg_name, 'Example description', ['tag1', 'tag2', 'tag3'], private, searchable,
adquiring_users, adquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
self.check_ds_values(url, private, searchable, adquiring_users, adquire_url)
self.check_user_access(pkg_name, url, True, True, True, private, searchable, adquire_url)
self.check_adquired(pkg_name, url, False, private)
adquiring_users, acquire_url, 'http://upm.es', 'UPM Main', 'Example Description', 'CSV')
self.check_ds_values(url, private, searchable, adquiring_users, acquire_url)
self.check_user_access(pkg_name, url, True, True, True, private, searchable, acquire_url)
self.check_acquired(pkg_name, url, False, private)
# Rest of users
rest_users = users[1:]
for user in rest_users:
self.logout()
self.login(user, user)
adquired = user in adquiring_users
acquired = user in adquiring_users
in_org = user in orgs[0]['users']
self.check_user_access(pkg_name, url, False, adquired, in_org, private, searchable, adquire_url)
self.check_adquired(pkg_name, url, adquired, private)
self.check_user_access(pkg_name, url, False, acquired, in_org, private, searchable, acquire_url)
self.check_acquired(pkg_name, url, acquired, private)