def test_build_workspace_from_rdf_template(self):
workspace, _junk = buildWorkspaceFromTemplate(self.rdfTemplate1, self.user)
get_global_workspace_data(self.workspace, self.user)
wiring_status = json.loads(workspace.wiringStatus)
self.assertEqual(len(wiring_status['connections']), 1)
self.assertEqual(wiring_status['connections'][0]['readOnly'], False)
def setUp(self):
super(WorkspaceCacheTestCase, self).setUp()
self.user = User.objects.get(username='******')
self.workspace = Workspace.objects.get(pk=1)
# Fill cache
get_global_workspace_data(self.workspace, self.user)
def test_build_workspace_from_rdf_template_utf8_char(self):
template = self.read_template('wt4.rdf')
workspace, _junk = buildWorkspaceFromTemplate(template, self.user)
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
for t in data['tabs']:
self.assertEqual(t['name'][0:7], u'Pestaña')
def test_fill_workspace_using_template(self):
fillWorkspaceUsingTemplate(self.workspace, self.template1)
data = get_global_workspace_data(self.workspace, self.user).get_data()
self.assertEqual(self.workspace.name, 'Testing')
self.assertEqual(len(data['tabs']), 2)
# Workspace template 2 adds a new Tab
fillWorkspaceUsingTemplate(self.workspace, self.template2)
data = get_global_workspace_data(self.workspace, self.user).get_data()
self.assertEqual(len(data['tabs']), 3)
# Check that we handle the case where there are 2 tabs with the same name
fillWorkspaceUsingTemplate(self.workspace, self.template2)
data = get_global_workspace_data(self.workspace, self.user).get_data()
self.assertEqual(len(data['tabs']), 4)
self.assertNotEqual(data['tabs'][2]['name'], data['tabs'][3]['name'])
def test_read_only_widgets(self):
template = self.read_template('wt6.xml')
workspace, _junk = buildWorkspaceFromTemplate(template, self.user)
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(len(data['tabs'][0]['iwidgets']), 3)
self.assertEqual(data['tabs'][0]['iwidgets'][0]['readOnly'], True)
def test_fill_workspace_using_template(self):
template = self.read_template('wt1.xml')
fillWorkspaceUsingTemplate(self.workspace, template)
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
self.assertEqual(self.workspace.name, 'Testing')
self.assertEqual(len(data['tabs']), 2)
template = self.read_template('wt2.xml')
# Workspace template 2 adds a new Tab
fillWorkspaceUsingTemplate(self.workspace, template)
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
self.assertEqual(len(data['tabs']), 3)
# Check that we handle the case where there are 2 tabs with the same name
fillWorkspaceUsingTemplate(self.workspace, template)
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
self.assertEqual(len(data['tabs']), 4)
self.assertNotEqual(data['tabs'][2]['name'], data['tabs'][3]['name'])
def test_shared_workspace(self):
from django.conf import settings
if not hasattr(settings, 'WORKSPACE_MANAGERS') or 'wirecloud.platform.workspace.workspace_managers.OrganizationWorkspaceManager' not in settings.WORKSPACE_MANAGERS:
raise unittest.SkipTest('OrganizationWorkspaceManager not enabled')
workspace = Workspace.objects.get(pk=1)
# Create a new group and share the workspace with it
group = Group.objects.create(name='test_users')
workspace.targetOrganizations.add(group)
other_user = User.objects.get(username='******')
other_user.groups.add(group)
other_user.save()
# Sync shared workspaces
sync_base_workspaces(other_user)
# Check that other_user can access to the shared workspace
data = json.loads(get_global_workspace_data(workspace, other_user).get_data())
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 2)
# Add a new iWidget to the workspace
tab = Tab.objects.get(pk=1)
iwidget_data = {
'widget': 'Test/Test Widget/1.0.0',
'name': 'test',
'top': 0,
'left': 0,
'width': 2,
'height': 2,
'zIndex': 1,
'layout': 0,
'icon_top': 0,
'icon_left': 0
}
SaveIWidget(iwidget_data, self.user, tab, {})
data = json.loads(get_global_workspace_data(workspace, other_user).get_data())
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 3)
def read(self, request, workspace_id):
workspace = get_object_or_404(Workspace, pk=workspace_id)
if not workspace.users.filter(pk=request.user.pk).exists():
return HttpResponseForbidden()
workspace_data = get_global_workspace_data(workspace, request.user)
return workspace_data.get_response()
def read(self, request, workspace_id):
workspace = get_object_or_404(Workspace, pk=workspace_id)
if not workspace.public and not (request.user.is_authenticated() and workspace.users.filter(pk=request.user.pk).exists()):
return build_error_response(request, 403, _("You don't have permission to access this workspace"))
workspace_data = get_global_workspace_data(workspace, request.user)
return workspace_data.get_response()
def test_get_global_workspace_data(self):
workspace = Workspace.objects.get(pk=1)
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(len(data['tabs']), 1)
tab = data['tabs'][0]
variables = tab['iwidgets'][0]['variables']
self.assertEqual(variables['password']['value'], '')
self.assertEqual(variables['password']['secure'], True)
self.assertEqual(variables['username']['value'], 'test_username')
self.assertEqual(variables['prop']['value'], 'test_data')
def check_workspace_with_params(self, workspace):
workspace_data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(workspace_data['extra_prefs'], {'param': {'type': 'text', 'inheritable': False, 'label': u'Parameter'}})
update_workspace_preferences(workspace, {'param': {'value': 'world'}});
workspace_data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
iwidget1 = None
iwidget2 = None
iwidget3 = None
for iwidget in workspace_data['tabs'][0]['iwidgets']:
if iwidget['name'] == 'Test (1)':
iwidget1 = iwidget
elif iwidget['name'] == 'Test (2)':
iwidget2 = iwidget
else:
iwidget3 = iwidget
# Check iwidget 1 data
iwidget1_vars = iwidget1['variables']
self.assertEqual(iwidget1_vars['text']['value'], 'initial world')
self.assertEqual(iwidget1_vars['text'].get('hidden', False), False)
self.assertEqual(iwidget1_vars['text']['readonly'], True)
# Check iwidget 2 data
iwidget2_vars = iwidget2['variables']
self.assertEqual(iwidget2_vars['text']['value'], 'initial world')
self.assertEqual(iwidget2_vars['text']['hidden'], True)
self.assertEqual(iwidget2_vars['text']['readonly'], True)
# Check iwidget 3 data
iwidget3_vars = iwidget3['variables']
self.assertEqual(iwidget3_vars['text']['value'], 'initial %(params.param)')
self.assertEqual(iwidget3_vars['text'].get('hidden', False), False)
self.assertEqual(iwidget3_vars['text'].get('readonly', False), False)
def test_shared_workspace(self):
workspace = Workspace.objects.get(pk=1)
# Create a new group and share the workspace with it
group = Group.objects.create(name='test_users')
workspace.targetOrganizations.add(group)
other_user = User.objects.get(username='******')
other_user.groups.add(group)
other_user.save()
# Sync shared workspaces
sync_base_workspaces(other_user)
# Check that other_user can access to the shared workspace
data = get_global_workspace_data(workspace, other_user).get_data()
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 2)
# Add a new iWidget to the workspace
tab = Tab.objects.get(pk=1)
iwidget_data = {
'widget': 'Test/Test Widget/1.0.0',
'name': 'test',
'top': 0,
'left': 0,
'width': 2,
'height': 2,
'zIndex': 1,
'layout': 0,
'icon_top': 0,
'icon_left': 0
}
SaveIWidget(iwidget_data, self.user, tab, {})
data = get_global_workspace_data(workspace, other_user).get_data()
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 3)
def test_create_empty_workspace(self):
workspace = createEmptyWorkspace('Testing', self.user)
user_workspace = UserWorkspace.objects.filter(user=self.user, workspace=workspace)
self.assertEqual(user_workspace.count(), 1)
self.assertEqual(user_workspace[0].active, True)
workspace_tabs = Tab.objects.filter(workspace=workspace)
self.assertEqual(workspace_tabs.count(), 1)
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(data['owned'], True)
self.assertEqual(data['shared'], False)
def test_merge_workspaces(self):
workspace = Workspace.objects.get(pk=1)
packageCloner = PackageCloner()
cloned_workspace = packageCloner.clone_tuple(workspace)
linkWorkspace(self.user, cloned_workspace.id, self.user)
packageCloner = PackageCloner()
packageCloner.merge_workspaces(cloned_workspace, workspace, self.user)
# Check cache invalidation
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
tab_list = data['tabs']
self.assertEqual(len(tab_list), 2)
def check_basic_workspace_structure(self, workspace):
wiring_status = json.loads(workspace.wiringStatus)
self.assertEqual(len(wiring_status['connections']), 1)
self.assertEqual(wiring_status['connections'][0]['readOnly'], False)
workspace_data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(workspace.name, 'Test Mashup')
self.assertEqual(len(workspace_data['tabs']), 1)
if workspace_data['tabs'][0]['iwidgets'][0]['name'] == 'Test (1)':
iwidget1 = workspace_data['tabs'][0]['iwidgets'][0]
iwidget2 = workspace_data['tabs'][0]['iwidgets'][1]
else:
iwidget1 = workspace_data['tabs'][0]['iwidgets'][1]
iwidget2 = workspace_data['tabs'][0]['iwidgets'][0]
# Check iwidget 1 data
self.assertEqual(iwidget1.get('readonly', False), False)
iwidget1_vars = iwidget1['variables']
self.assertEqual(iwidget1_vars['list']['value'], 'default')
self.assertEqual(iwidget1_vars['list']['hidden'], True)
self.assertEqual(iwidget1_vars['list']['readonly'], True)
self.assertEqual(iwidget1_vars['text']['value'], 'initial text')
self.assertEqual(iwidget1_vars['text']['hidden'], False)
self.assertEqual(iwidget1_vars['text']['readonly'], True)
# Check iwidget 2 data
self.assertEqual(iwidget1.get('readonly', False), False)
iwidget2_vars = iwidget2['variables']
self.assertEqual(iwidget2_vars['list']['value'], 'value1')
self.assertEqual(iwidget2_vars['list'].get('hidden', False), False)
self.assertEqual(iwidget2_vars['list'].get('readonly', False), False)
self.assertEqual(iwidget2_vars['text']['value'], 'value2')
self.assertEqual(iwidget2_vars['text'].get('hidden', False), False)
self.assertEqual(iwidget2_vars['text'].get('readonly', False), False)
def test_variable_updating_invalidates_cache(self):
client = Client()
put_data = [
{'id': 1, 'value': 'new_password'},
{'id': 2, 'value': 'new_username'},
{'id': 4, 'value': 'new_data'},
]
put_data = json.dumps(put_data, ensure_ascii=False).encode('utf-8')
client.login(username='******', password='******')
result = client.post(reverse('wirecloud.variable_collection', kwargs={'workspace_id': 1}), put_data, content_type='application/json', HTTP_HOST='localhost', HTTP_REFERER='http://localhost')
self.assertEqual(result.status_code, 204)
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
variables = data['tabs'][0]['iwidgets'][0]['variables']
self.assertEqual(variables['password']['value'], '')
self.assertEqual(variables['password']['secure'], True)
self.assertEqual(variables['username']['value'], 'new_username')
self.assertEqual(variables['prop']['value'], 'new_data')
def test_widget_instantiation_invalidates_cache(self):
tab = Tab.objects.get(pk=1)
iwidget_data = {
'widget': 'Test/Test Widget/1.0.0',
'name': 'test',
'top': 0,
'left': 0,
'width': 2,
'height': 2,
'zIndex': 1,
'layout': 0,
'icon_top': 0,
'icon_left': 0
}
SaveIWidget(iwidget_data, self.user, tab, {})
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 3)
def test_complex_workspaces_rdf(self):
workspace, _junk = buildWorkspaceFromTemplate(self.rdfTemplate3, self.user)
data = get_global_workspace_data(workspace, self.user).get_data()
self.assertEqual(len(data['tabs']), 4)
self.assertEqual(data['tabs'][0]['name'], u'Tab')
self.assertEqual(len(data['tabs'][0]['iwidgets']), 1)
self.assertEqual(data['tabs'][1]['name'], u'Tab 2')
self.assertEqual(len(data['tabs'][1]['iwidgets']), 1)
self.assertEqual(data['tabs'][2]['name'], u'Tab 3')
self.assertEqual(len(data['tabs'][2]['iwidgets']), 0)
self.assertEqual(data['tabs'][3]['name'], u'Tab 4')
self.assertEqual(len(data['tabs'][3]['iwidgets']), 0)
wiring = data['wiring']
self.assertEqual(len(wiring['connections']), 1)
self.assertEqual(wiring['connections'][0]['source']['type'], 'iwidget')
self.assertEqual(wiring['connections'][0]['source']['endpoint'], 'event')
self.assertEqual(wiring['connections'][0]['target']['type'], 'iwidget')
self.assertEqual(wiring['connections'][0]['target']['endpoint'], 'slot')
def test_complex_workspaces(self):
template3 = self.read_template('wt3.xml')
workspace, _junk = buildWorkspaceFromTemplate(template3, self.user)
data = json.loads(get_global_workspace_data(workspace, self.user).get_data())
self.assertEqual(len(data['tabs']), 4)
self.assertEqual(data['tabs'][0]['name'], 'Tab')
self.assertEqual(len(data['tabs'][0]['iwidgets']), 1)
self.assertEqual(data['tabs'][1]['name'], 'Tab 2')
self.assertEqual(len(data['tabs'][1]['iwidgets']), 1)
self.assertEqual(data['tabs'][2]['name'], 'Tab 3')
self.assertEqual(len(data['tabs'][2]['iwidgets']), 0)
self.assertEqual(data['tabs'][3]['name'], 'Tab 4')
self.assertEqual(len(data['tabs'][3]['iwidgets']), 0)
wiring_status = data['wiring']
self.assertEqual(len(wiring_status['operators']), 1)
self.assertEqual(len(wiring_status['connections']), 1)
self.assertEqual(wiring_status['connections'][0]['source']['type'], 'iwidget')
self.assertEqual(wiring_status['connections'][0]['source']['endpoint'], 'event')
self.assertEqual(wiring_status['connections'][0]['target']['type'], 'iwidget')
self.assertEqual(wiring_status['connections'][0]['target']['endpoint'], 'slot')
def read(self, request, workspace_id):
workspace = get_object_or_404(Workspace, users__id=request.user.id, pk=workspace_id)
workspace_data = get_global_workspace_data(workspace, request.user)
return workspace_data.get_response()
def test_workspace_data_is_cached(self):
workspace_info = get_global_workspace_data(self.workspace, self.user)
self.assertEqual(self.initial_info.timestamp, workspace_info.timestamp)
def test_build_workspace_from_rdf_template_utf8_char(self):
workspace, _junk = buildWorkspaceFromTemplate(self.rdfTemplate4, self.user)
data = get_global_workspace_data(workspace, self.user).get_data()
for t in data['tabs']:
self.assertEqual(t['name'][0:7], u'Pestaña')
build_error_response(request, 424, _('Downloaded invalid resource description from: %(url)s') % {'url': resource.template_uri})
try:
check_mashup_dependencies(template, request.user)
except MissingDependencies, e:
details = {
'missingDependencies': e.missing_dependencies,
}
return build_error_response(request, 422, unicode(e), details=details)
if dry_run:
return HttpResponse(status=204)
workspace, _junk = buildWorkspaceFromTemplate(template, request.user, True)
workspace_data = get_global_workspace_data(workspace, request.user)
return workspace_data.get_response(status_code=201, cacheable=False)
class WorkspaceEntry(Resource):
@authentication_required
def read(self, request, workspace_id):
workspace = get_object_or_404(Workspace, pk=workspace_id)
if not workspace.users.filter(pk=request.user.pk).exists():
return HttpResponseForbidden()
workspace_data = get_global_workspace_data(workspace, request.user)
def create(self, request):
try:
data = json.loads(request.body)
except ValueError as e:
msg = _("malformed json data: %s") % unicode(e)
return build_error_response(request, 400, msg)
workspace_name = data.get('name', '').strip()
workspace_id = data.get('workspace', '')
mashup_id = data.get('mashup', '')
try:
allow_renaming = normalize_boolean_param('allow_renaming', data.get('allow_renaming', False))
dry_run = normalize_boolean_param('allow_renaming', data.get('dry_run', False))
except (TypeError, ValueError) as e:
return build_error_response(request, 422, unicode(e))
if mashup_id == '' and workspace_id == '' and workspace_name == '':
return build_error_response(request, 422, _('Missing name parameter'))
elif mashup_id != '' and workspace_id != '':
return build_error_response(request, 422, _('Workspace and mashup parameters cannot be used at the same time'))
if mashup_id == '' and workspace_id == '':
if not is_valid_name(workspace_name):
return build_error_response(request, 422, _('invalid workspace name'))
if dry_run:
return HttpResponse(status=204)
try:
workspace = createEmptyWorkspace(workspace_name, request.user, allow_renaming=allow_renaming)
except IntegrityError:
msg = _('A workspace with the given name already exists')
return build_error_response(request, 409, msg)
else:
if mashup_id != '':
values = mashup_id.split('/', 3)
if len(values) != 3:
return build_error_response(request, 422, _('invalid mashup id'))
(mashup_vendor, mashup_name, mashup_version) = values
try:
resource = CatalogueResource.objects.get(vendor=mashup_vendor, short_name=mashup_name, version=mashup_version)
if not resource.is_available_for(request.user) or resource.resource_type() != 'mashup':
raise CatalogueResource.DoesNotExist
except CatalogueResource.DoesNotExist:
return build_error_response(request, 422, _('Mashup not found: %(mashup_id)s') % {'mashup_id': mashup_id})
if resource.fromWGT:
base_dir = catalogue.wgt_deployer.get_base_dir(mashup_vendor, mashup_name, mashup_version)
wgt_file = WgtFile(os.path.join(base_dir, resource.template_uri))
template = TemplateParser(wgt_file.get_template())
else:
template = download_http_content(resource.template_uri, user=request.user)
try:
template = TemplateParser(template)
except:
build_error_response(request, 422, _('Downloaded invalid resource description from: %(url)s') % {'url': resource.template_uri})
else:
from_ws = get_object_or_404(Workspace, id=workspace_id)
if from_ws.public is False and not request.user.is_superuser and from_ws.creator != request.user:
return build_error_response(request, 403, _('You are not allowed to read from workspace %s') % workspace_id)
options = {
'vendor': 'api',
'name': from_ws.name,
'version': '1.0',
'title': '',
'description': 'Temporal mashup for the workspace copy operation',
'email': '*****@*****.**',
}
template = TemplateParser(build_json_template_from_workspace(options, from_ws, from_ws.creator))
try:
check_mashup_dependencies(template, request.user)
except MissingDependencies as e:
details = {
'missingDependencies': e.missing_dependencies,
}
return build_error_response(request, 422, unicode(e), details=details)
if dry_run:
return HttpResponse(status=204)
if workspace_name == '':
workspace_name = None
try:
workspace, _junk = buildWorkspaceFromTemplate(template, request.user, allow_renaming=allow_renaming, new_name=workspace_name)
except IntegrityError:
msg = _('A workspace with the given name already exists')
return build_error_response(request, 409, msg)
workspace_data = get_global_workspace_data(workspace, request.user)
return workspace_data.get_response(status_code=201, cacheable=False)
def test_widget_deletion_invalidates_cache(self):
deleteIWidget(IWidget.objects.get(pk=1), self.user)
data = json.loads(get_global_workspace_data(self.workspace, self.user).get_data())
iwidget_list = data['tabs'][0]['iwidgets']
self.assertEqual(len(iwidget_list), 1)
