def test_build_rdf_template_from_workspace(self):
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'author': u'test',
'email': u'*****@*****.**',
'readOnlyWidgets': True,
}
# Basic info
graph = build_rdf_template_from_workspace(options, self.workspace, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.assertRDFElement(graph, mashup_uri, self.DCTERMS, 'title', u'Test Mashup')
self.assertRDFElement(graph, mashup_uri, self.USDL, 'versionInfo', u'1')
vendor = graph.objects(mashup_uri, self.USDL['hasProvider']).next()
self.assertRDFElement(graph, vendor, self.FOAF, 'name', u'Wirecloud Test Suite')
addr = graph.objects(mashup_uri, self.VCARD['addr']).next()
self.assertRDFElement(graph, addr, self.VCARD, 'email', u'*****@*****.**')
author = graph.objects(mashup_uri, self.DCTERMS['creator']).next()
self.assertRDFElement(graph, author, self.FOAF, 'name', u'test')
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'Tab')
# Workspace with iwidgets
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'author': u'test',
'email': u'*****@*****.**',
'readOnlyWidgets': True,
}
graph = build_rdf_template_from_workspace(options, self.workspace_with_iwidgets, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.assertRDFElement(graph, mashup_uri, self.DCTERMS, 'title', u'Test Mashup')
self.assertRDFElement(graph, mashup_uri, self.USDL, 'versionInfo', u'1')
vendor = graph.objects(mashup_uri, self.USDL['hasProvider']).next()
self.assertRDFElement(graph, vendor, self.FOAF, 'name', u'Wirecloud Test Suite')
addr = graph.objects(mashup_uri, self.VCARD['addr']).next()
self.assertRDFElement(graph, addr, self.VCARD, 'email', u'*****@*****.**')
author = graph.objects(mashup_uri, self.DCTERMS['creator']).next()
self.assertRDFElement(graph, author, self.FOAF, 'name', u'test')
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'tab')
self.assertRDFCount(graph, tab, self.WIRE_M, 'hasiWidget', 2)
def test_build_rdf_template_from_workspace(self):
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'authors': u'test',
'email': u'*****@*****.**',
}
# Basic info
graph = build_rdf_template_from_workspace(options, self.workspace, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.check_basic_rdf_workspace_template_info(graph, mashup_uri)
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'Tab')
self.check_empty_rdf_wiring_info(graph, mashup_uri)
# Workspace with iwidgets
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'authors': u'test',
'email': u'*****@*****.**',
'readOnlyWidgets': False,
}
graph = build_rdf_template_from_workspace(options, self.workspace_with_iwidgets, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.check_basic_rdf_workspace_template_info(graph, mashup_uri)
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'tab')
self.assertRDFCount(graph, tab, self.WIRE_M, 'hasiWidget', 2)
for iwidget in graph.objects(tab, self.WIRE_M['hasiWidget']):
self.assertRDFElement(graph, iwidget, self.WIRE_M, 'readonly', 'false', optional=True)
self.assertRDFCount(graph, iwidget, self.WIRE_M, 'hasiWidgetPreference', 2)
username_found = password_found = False
for preference in graph.objects(iwidget, self.WIRE_M['hasiWidgetPreference']):
self.assertRDFElement(graph, preference, self.WIRE_M, 'readonly', u'false', optional=True)
self.assertRDFElement(graph, preference, self.WIRE_M, 'hidden', u'false', optional=True)
name = self.get_rdf_element(graph, preference, self.DCTERMS, 'title')
if unicode(name) == u'username':
username_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_username')
elif unicode(name) == u'password':
password_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_password')
else:
self.fail()
self.assertTrue(username_found and password_found)
self.check_empty_rdf_wiring_info(graph, mashup_uri)
def test_build_rdf_template_from_workspace_forced_values(self):
# Workspace with iwidgets
options = {
'vendor': 'Wirecloud Test Suite',
'name': 'Test Mashup',
'version': '1',
'author': 'test',
'email': '*****@*****.**',
'readOnlyWidgets': True,
'parametrization': {
'1': {
'username': {'source': 'current', 'status': 'readonly', 'value': 'default'},
'password': {'source': 'current', 'status': 'hidden', 'value': 'initial text'},
}
},
}
graph = build_rdf_template_from_workspace(options, self.workspace_with_iwidgets, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFCount(graph, tab, self.WIRE_M, 'hasiWidget', 2)
for iwidget in graph.objects(tab, self.WIRE_M['hasiWidget']):
name = unicode(self.get_rdf_element(graph, iwidget, self.DCTERMS, 'title'))
self.assertRDFCount(graph, iwidget, self.WIRE_M, 'hasiWidgetPreference', 2)
preferences = graph.objects(iwidget, self.WIRE_M['hasiWidgetPreference'])
username_found = password_found = False
if name == 'Test Widget':
for preference in preferences:
self.assertRDFElement(graph, preference, self.WIRE_M, 'readonly', u'true')
name = self.get_rdf_element(graph, preference, self.DCTERMS, 'title')
if unicode(name) == u'username':
username_found = True
self.assertRDFElement(graph, preference, self.WIRE_M, 'hidden', u'false', optional=True)
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'default')
elif unicode(name) == u'password':
password_found = True
self.assertRDFElement(graph, preference, self.WIRE_M, 'hidden', u'true')
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'initial text')
else:
self.fail()
elif name == 'Test Widget 2':
for preference in preferences:
name = self.get_rdf_element(graph, preference, self.DCTERMS, 'title')
if unicode(name) == u'username':
username_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_username')
elif unicode(name) == u'password':
password_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_password')
else:
self.fail()
self.assertTrue(username_found and password_found)
def create(self, request, workspace_id):
content_type = get_content_type(request)[0]
image_file = None
if content_type == 'application/json':
received_json = request.body
else:
received_json = request.POST['json']
image_file = request.FILES.get('image', None)
try:
options = json.loads(received_json)
except ValueError as e:
msg = _("malformed json data: %s") % unicode(e)
return build_error_response(request, 400, msg)
missing_fields = check_json_fields(options, ('name', 'vendor', 'version', 'email'))
if len(missing_fields) > 0:
return build_error_response(request, 400, _('Malformed JSON. The following field(s) are missing: %(fields)s.') % {'fields': missing_fields})
if not is_valid_vendor(options['vendor']):
return build_error_response(request, 400, _('Invalid vendor'))
if not is_valid_name(options['name']):
return build_error_response(request, 400, _('Invalid name'))
if not is_valid_version(options['version']):
return build_error_response(request, 400, _('Invalid version number'))
workspace = get_object_or_404(Workspace, id=workspace_id)
if image_file is not None:
image_filename = 'images/catalogue' + os.path.splitext(image_file.name)[1]
options['image'] = image_filename
description = build_rdf_template_from_workspace(options, workspace, request.user)
f = StringIO()
zf = zipfile.ZipFile(f, 'w')
zf.writestr('config.xml', bytes(description.serialize(format='pretty-xml')))
if image_file is not None:
zf.writestr(image_filename, image_file.read())
zf.close()
wgt_file = WgtFile(f)
market_managers = get_market_managers(request.user)
try:
market_managers['local'].publish(None, wgt_file, request.user, options, request)
except Exception, e:
return build_error_response(request, 502, unicode(e))
def test_build_rdf_template_from_workspace_utf8_char(self):
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup with ñ',
'version': u'1',
'author': u'author with é',
'email': u'*****@*****.**',
'readOnlyWidgets': True,
}
graph = build_rdf_template_from_workspace(options, self.workspace, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.assertRDFElement(graph, mashup_uri, self.DCTERMS, 'title', u'Test Mashup with ñ')
self.assertRDFElement(graph, mashup_uri, self.USDL, 'versionInfo', u'1')
vendor = graph.objects(mashup_uri, self.USDL['hasProvider']).next()
self.assertRDFElement(graph, vendor, self.FOAF, 'name', u'Wirecloud Test Suite')
addr = graph.objects(mashup_uri, self.VCARD['addr']).next()
self.assertRDFElement(graph, addr, self.VCARD, 'email', u'*****@*****.**')
author = graph.objects(mashup_uri, self.DCTERMS['creator']).next()
self.assertRDFElement(graph, author, self.FOAF, 'name', u'author with é')
def test_build_rdf_template_from_workspace(self):
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'author': u'test',
'email': u'*****@*****.**',
'readOnlyWidgets': True,
}
# Basic info
graph = build_rdf_template_from_workspace(options, self.workspace, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.assertRDFElement(graph, mashup_uri, self.DCTERMS, 'title', u'Test Mashup')
self.assertRDFElement(graph, mashup_uri, self.USDL, 'versionInfo', u'1')
vendor = graph.objects(mashup_uri, self.USDL['hasProvider']).next()
self.assertRDFElement(graph, vendor, self.FOAF, 'name', u'Wirecloud Test Suite')
addr = graph.objects(mashup_uri, self.VCARD['addr']).next()
self.assertRDFElement(graph, addr, self.VCARD, 'email', u'*****@*****.**')
author = graph.objects(mashup_uri, self.DCTERMS['creator']).next()
self.assertRDFElement(graph, author, self.FOAF, 'name', u'test')
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'Tab')
# Workspace with iwidgets
options = {
'vendor': u'Wirecloud Test Suite',
'name': u'Test Mashup',
'version': u'1',
'author': u'test',
'email': u'*****@*****.**',
'readOnlyWidgets': True,
}
graph = build_rdf_template_from_workspace(options, self.workspace_with_iwidgets, self.user)
mashup_uri = graph.subjects(self.RDF['type'], self.WIRE_M['Mashup']).next()
self.assertRDFElement(graph, mashup_uri, self.DCTERMS, 'title', u'Test Mashup')
self.assertRDFElement(graph, mashup_uri, self.USDL, 'versionInfo', u'1')
vendor = graph.objects(mashup_uri, self.USDL['hasProvider']).next()
self.assertRDFElement(graph, vendor, self.FOAF, 'name', u'Wirecloud Test Suite')
addr = graph.objects(mashup_uri, self.VCARD['addr']).next()
self.assertRDFElement(graph, addr, self.VCARD, 'email', u'*****@*****.**')
author = graph.objects(mashup_uri, self.DCTERMS['creator']).next()
self.assertRDFElement(graph, author, self.FOAF, 'name', u'test')
self.assertRDFCount(graph, mashup_uri, self.WIRE_M, 'hasTab', 1)
tab = graph.objects(mashup_uri, self.WIRE_M['hasTab']).next()
self.assertRDFElement(graph, tab, self.DCTERMS, 'title', u'tab')
self.assertRDFCount(graph, tab, self.WIRE_M, 'hasiWidget', 2)
for iwidget in graph.objects(tab, self.WIRE_M['hasiWidget']):
self.assertRDFElement(graph, iwidget, self.WIRE, 'readonly', 'true')
self.assertRDFCount(graph, iwidget, self.WIRE_M, 'hasiWidgetPreference', 2)
username_found = password_found = False
for preference in graph.objects(iwidget, self.WIRE_M['hasiWidgetPreference']):
self.assertRDFElement(graph, preference, self.WIRE_M, 'readonly', u'false', optional=True)
self.assertRDFElement(graph, preference, self.WIRE_M, 'hidden', u'false', optional=True)
name = self.get_rdf_element(graph, preference, self.DCTERMS, 'title')
if unicode(name) == u'username':
username_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_username')
elif unicode(name) == u'password':
password_found = True
self.assertRDFElement(graph, preference, self.WIRE, 'value', u'test_password')
else:
self.fail()
self.assertTrue(username_found and password_found)
wiring = graph.objects(mashup_uri, self.WIRE_M['hasMashupWiring']).next()
self.assertRDFCount(graph, wiring, self.WIRE_M, 'hasConnection', 0)
self.assertRDFCount(graph, wiring, self.WIRE_M, 'hasiOperator', 0)
self.assertRDFCount(graph, wiring, self.WIRE_M, 'hasWiringView', 0)
def create(self, request, workspace_id):
import wirecloud.catalogue.utils as catalogue_utils
content_type = get_content_type(request)[0]
image_file = None
smartphoneimage_file = None
if content_type == 'application/json':
received_json = request.body
else:
received_json = request.POST['json']
image_file = request.FILES.get('image', None)
smartphoneimage_file = request.FILES.get('smartphoneimage', None)
try:
options = json.loads(received_json)
except ValueError as e:
msg = _("malformed json data: %s") % unicode(e)
return build_error_response(request, 400, msg)
missing_fields = check_json_fields(options, ('name', 'vendor', 'version'))
if len(missing_fields) > 0:
return build_error_response(request, 400, _('Malformed JSON. The following field(s) are missing: %(fields)s.') % {'fields': missing_fields})
if not is_valid_vendor(options['vendor']):
return build_error_response(request, 400, _('Invalid vendor'))
if not is_valid_name(options['name']):
return build_error_response(request, 400, _('Invalid name'))
if not is_valid_version(options['version']):
return build_error_response(request, 400, _('Invalid version number'))
workspace = get_object_or_404(Workspace, id=workspace_id)
if image_file is not None:
image_filename = 'images/catalogue' + os.path.splitext(image_file.name)[1]
options['image'] = image_filename
if smartphoneimage_file is not None:
smartphoneimage_filename = 'images/smartphone' + os.path.splitext(smartphoneimage_file.name)[1]
options['smartphoneimage'] = smartphoneimage_filename
description = build_rdf_template_from_workspace(options, workspace, request.user)
# Build mashup wgt file
f = BytesIO()
zf = zipfile.ZipFile(f, 'w')
zf.writestr('config.xml', bytes(description.serialize(format='pretty-xml')))
if image_file is not None:
zf.writestr(image_filename, image_file.read())
if smartphoneimage_file is not None:
zf.writestr(smartphoneimage_filename, smartphoneimage_file.read())
for resource_info in options['embedded']:
(vendor, name, version) = (resource_info['vendor'], resource_info['name'], resource_info['version'])
resource = CatalogueResource.objects.get(vendor=vendor, short_name=name, version=version)
base_dir = catalogue_utils.wgt_deployer.get_base_dir(vendor, name, version)
zf.write(os.path.join(base_dir, resource.template_uri), resource_info['src'])
zf.close()
wgt_file = WgtFile(f)
resource = get_local_catalogue().publish(None, wgt_file, request.user, options, request)
return HttpResponse(json.dumps(resource.get_processed_info(request), ensure_ascii=False), status=201, content_type='application/json; charset=utf-8')
