def test(self=None):
err_msg = []
check, err_msg, tmp_urls = CORE_READ_URL(occi_config['occi.tests.category'])
if not tmp_urls:
err_msg += ["OCCI entity URL not found!"]
return [False, err_msg]
url = urlparse.urlparse(tmp_urls[0]).path
body, response_headers, http_status, content_type = occi_curl(url=url)
check_exist1, tmp_err_msg = check_http_status("200 OK", http_status)
err_msg += tmp_err_msg
body, response_headers, http_status, content_type = occi_curl(url=url, custom_request='DELETE')
check_delete1, tmp_err_msg = check_http_status("200 OK", http_status)
err_msg += tmp_err_msg
# It takes some time to delete machine, second delete action force it
# Not testing result of the operation (various backends have different behaviour)
body, response_headers, http_status, content_type = occi_curl(url=url, custom_request='DELETE')
body, response_headers, http_status, content_type = occi_curl(url=url)
check_exist2, tmp_err_msg = check_http_status("404 Not Found", http_status)
err_msg += tmp_err_msg
Test.clear_categories()
return [check_exist1 and check_exist2 and check_delete1, err_msg]
def CORE_READ002_COMMON(category, links=[]):
check_url = True
check_200ok = False
err_msg = []
headers = []
headers.append('Content-Type: text/occi')
headers += renderer_httpheaders.render_category(occi.Category({'term': category['term'], 'scheme': category['scheme'], 'class': category['class']}))[1]
body, response_headers, http_status, content_type = occi_curl(url=category['location'], headers=headers)
try:
locations = renderer.parse_locations(body, response_headers)
except occi.ParseError as pe:
locations = []
check_url = False
err_msg.append(str(pe))
links[0:] = locations
if re.match(r'^HTTP/.* 200 OK', http_status):
check_200ok = True
else:
err_msg.append('Returned HTTP status is not 200 OK (%s)' % http_status)
check_ct2, tmp_err_msg = check_content_type(content_type)
err_msg += tmp_err_msg
return [check_url and check_ct2 and check_200ok, err_msg]
def test(self=None):
err_msg = []
body, response_headers, http_status, content_type, check_pretest = Test.pretest_http_status("200 OK", err_msg)
if not check_pretest:
return [False, err_msg]
#kind = Test.search_category({'class': 'kind'})
kind = Test.search_category({'class': 'kind', 'term': 'compute'})
#print kind
if kind:
for item in ['location', 'term', 'scheme']:
if item not in kind.keys():
err_msg.append('No %s in OCCI Kind' % item)
return [False, err_msg]
else:
err_msg.append('No OCCI Kind found')
return [False, err_msg]
new_cat_s, new_cat_h = renderer.render_resource(
categories=[
occi.Category({
'term': 'compute',
'scheme': 'http://schemas.ogf.org/occi/infrastructure#',
'class': 'kind',
'title': 'titulek',
}),
],
attributes=[
occi.Attribute({
'name': 'occi.core.id',
'value': gen_id('Compute'),
}),
occi.Attribute({
'name': 'occi.core.title',
'value': 'titulek',
}),
occi.Attribute({
'name': 'occi.core.summary',
'value': 'sumarko',
}),
occi.Attribute({
'name': 'occi.compute.architecture',
'value': 'arch',
}),
]
)
body, response_headers, http_status, content_type = occi_curl(url=kind['location'], headers=['Content-Type: %s' % occi_config['mimetype']] + new_cat_h, post=new_cat_s, custom_request='POST')
Test.clear_categories()
check_create, tmp_err_msg = check_http_status("201 Created", http_status)
err_msg += tmp_err_msg
if not check_create:
print >> sys.stderr, body
return [check_create, err_msg]
def test(self=None):
network_links = []
storage_links = []
err_msg = []
check = True
body, response_headers, http_status, content_type, check_pretest = Test.pretest_http_status("200 OK", err_msg)
if content_type:
check, tmp_err_msg = check_content_type(content_type)
err_msg += tmp_err_msg
if not check_pretest:
return [False, err_msg]
storage = Test.search_category({'term': 'storage', 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
network = Test.search_category({'term': 'network', 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
check_read, tmp_err_msg = CORE_READ002_COMMON(category=storage, links=storage_links)
if not check_read:
check = False
err_msg += tmp_err_msg
check_read, tmp_err_msg = CORE_READ002_COMMON(category=network, links=network_links)
if not check_read:
check = False
err_msg += tmp_err_msg
print storage_links
print network_links
if not storage_links or not network_links:
if not storage_links:
err_msg.append('No storage found')
if not network_links:
err_msg.append('No network found')
return [False, err_msg]
compute = Test.search_category({'term': 'compute', 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
new_compute = 'Category: %s; scheme="%s"; class="%s"\n\r\
Link: <%s>; rel="%s"; category="%s"\n\r\
Link: <%s>; rel="%s"; category="%s"\n\r\
' % (compute['term'], compute['scheme'], compute['class'], storage_links[0], storage['scheme'] + storage['term'], 'http://schemas.ogf.org/occi/infrastructure#storagelink', network_links[0], network['scheme'] + network['term'], 'http://schemas.ogf.org/occi/infrastructure#networkinterface')
body, response_headers, http_status, content_type = occi_curl(url=compute['location'], headers=['Content-Type: text/plain'], post=new_compute)
check_create, tmp_err_msg = check_http_status("201 Created", http_status)
err_msg += tmp_err_msg
if not check_create:
print >> sys.stderr, body
Test.clear_categories()
return [check and check_create, err_msg]
def test(self=None):
err_msg = []
new_mixin = 'Category: stufik; scheme="http://example.com/occi/my_stuff#"; class="mixin"; location: "/mixin/resource_tpl/extra_large/", rel: "http://schemas.ogf.org/occi/infrastructure#resource_tpl"'
#new_mixin = 'Category: stufik; scheme="http://example.com/occi/my_stuff#"; class="mixin"; rel="http:/example.com/occi/something_else#mixin"; location="/my_stuff/"'
body, response_headers, http_status, content_type = occi_curl(url='/-/', headers=['Content-Type: text/plain'], post=new_mixin)
check_create, tmp_err_msg = check_http_status("200 OK", http_status)
err_msg += tmp_err_msg
if not check_create:
print >> sys.stderr, body
return [check_create, err_msg]
def test(self=None):
err_msg = []
filtered_categories = []
check = True
body, response_headers, http_status, content_type, check_pretest = Test.pretest_http_status("200 OK", err_msg)
if not Test.categories:
err_msg += ['No categories returned']
return [False, err_msg]
filter = occi.Category({
'term': Test.categories[0]['term'],
'scheme': Test.categories[0]['scheme'],
'class': Test.categories[0]['class'],
})
cat_in = []
cat_in.append('Content-Type: text/occi')
cat_in += renderer_httpheaders.render_category(filter)[1]
body, response_headers, http_status, content_type = occi_curl(headers=cat_in)
check_ct, err_msg = check_content_type(content_type)
if not re.match(r'^HTTP/.* 200 OK', http_status):
check = False
err_msg.append('HTTP status on filter not 200 OK (%s)' % http_status)
check_rct, tmp_err_msg = check_requested_content_type(content_type)
err_msg += tmp_err_msg
try:
filtered_categories = renderer.parse_categories(body, response_headers)
except occi.ParseError as pe:
check = False
err_msg.append(str(pe))
check_filter = False
for cat in filtered_categories:
if match_category(cat, filter):
check_filter = True
break
if not check_filter:
err_msg.append('Category "%s" (scheme "%s") not in filtered result' % (filter['term'], filter['scheme']))
return [check and check_pretest and check_ct and check_rct and check_filter, err_msg]
def get_categories(self, err_msg):
check_parse = True
body, response_headers, http_status, content_type = occi_curl(mimetype=occi_config['mimetype.big'])
try:
categories = renderer_big.parse_categories(body, response_headers)
except occi.ParseError as pe:
categories = []
check_parse = False
err_msg.append(str(pe))
if occi_config['curlverbose']:
print '==== CATEGORIES ===='
if check_parse:
for category in categories:
print category
else:
print 'ERROR: %s' % err_msg[-1]
print '===================='
Test.categories = categories
return [check_parse, body, response_headers, http_status, content_type]
def CORE_READ_URL(filter):
err_msg = []
check_200ok = False
check = True
body, response_headers, http_status, content_type, check_pretest = Test.pretest_http_status("200 OK", err_msg)
if content_type:
check, tmp_err_msg = check_content_type(content_type)
err_msg += tmp_err_msg
if not check_pretest:
return [False, err_msg, None]
mixin = Test.search_category(filter)
#kind = Test.search_category({'class': 'kind'})
if not mixin:
err_msg.append('No required OCCI Category found')
return [False, err_msg, None]
for category in [mixin]:
body, response_headers, http_status, content_type = occi_curl(url=category['location'])
try:
locations = renderer.parse_locations(body, response_headers)
except occi.ParseError as pe:
locations = []
check = False
err_msg.append(str(pe))
if re.match(r'^HTTP/.* 200 OK', http_status):
check_200ok = True
else:
err_msg.append('Returned HTTP status is not 200 OK (%s)' % http_status)
return [check_pretest and check and check_200ok, err_msg, locations]
def INFRA_CREATE_LINK(resource_name, resource_type):
"""
Opennebula requires running compute instance.
"""
err_msg = []
check = True
check_link = False
compute_links = []
resource_links = []
resourcelink = None
attributes = {}
attribute_definitions = []
body, response_headers, http_status, content_type, check_pretest = Test.pretest_http_status("200 OK", err_msg)
if not check_pretest:
return [False, err_msg]
compute = Test.search_category({'term': 'compute', 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
resource = Test.search_category({'term': resource_name, 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
check_read, tmp_err_msg = CORE_READ002_COMMON(category=compute, links=compute_links)
if not check_read:
check = False
err_msg += tmp_err_msg
check_read, tmp_err_msg = CORE_READ002_COMMON(category=resource, links=resource_links)
if not check_read:
check = False
err_msg += tmp_err_msg
#print resource_links
#print compute_links
if not resource_links or not compute_links:
if not resource_links:
err_msg.append('No %s found' % resource_name)
if not compute_links:
err_msg.append('No compute found')
return [False, err_msg]
resourcelink = Test.search_category({'term': '%s%s' % (resource_name, resource_type), 'scheme': 'http://schemas.ogf.org/occi/infrastructure#', 'class': 'kind'})
if not resourcelink:
err_msg.append('No %slink kind found' % resource_name)
return [False, err_msg]
#print resourcelink
if 'attributes' in resourcelink:
attribute_definitions += resourcelink['attributes']
attributes['occi.core.id'] = occi.Attribute({'name': 'occi.core.id', 'value': gen_id('%s%s' % (resource_name.capitalize(), resource_type))})
attributes['occi.core.source'] = occi.Attribute({'name': 'occi.core.source', 'value': compute_links[0]})
attributes['occi.core.target'] = occi.Attribute({'name': 'occi.core.target', 'value': resource_links[0]})
if not get_attributes(attribute_definitions, attributes, err_msg):
check = False
#print attributes
new_resourcelink_s, new_resourcelink_h = renderer.render_resource(
categories=[
occi.Category({'term': resourcelink['term'], 'scheme': resourcelink['scheme'], 'class': resourcelink['class']}),
],
links=None,
attributes=attributes.values()
)
body, response_headers, http_status, content_type = occi_curl(url=resourcelink['location'], headers=['Content-Type: %s' % occi_config['mimetype']] + new_resourcelink_h, post=new_resourcelink_s, custom_request='POST')
check_create, tmp_err_msg = check_http_status("201 Created", http_status)
err_msg += tmp_err_msg
if not check_create:
print >> sys.stderr, body
Test.clear_categories()
resource_link = resource_links[0]
resource_link_rel = urlparse.urlparse(resource_link).path
body, response_headers, http_status, content_type = occi_curl(base_url=compute_links[0], url='')
try:
result_categories, result_links, result_attributes = renderer.parse_resource(body, response_headers)
except occi.ParseError as pe:
err_msg += [str(pe)]
#print resource_link
#print result_links
for l in result_links:
# accept both: relative and absolute URI
if l['uri'] == resource_link or l['uri'] == resource_link_rel:
check_link = True
break
if not check_link:
err_msg += ["OCCI Compute Resource is NOT linked with OCCI %s Resource!" % (resource_name.capitalize())]
print >> sys.stderr, body
return [check and check_create and check_link, err_msg]
def INFRA_CREATE_COMMON(resource, categories, additional_attributes, err_msg):
"""Generic help function to create OCCI Infrastructure resources.
HTTP Headers renderer is always used.
:param string resource: OCCI Category term (compute, storage, network)
:param occi.Category categories[]: OCCI Categories to add to rendering
:param occi.AttributeDefinition additional_attributes[]: additional attributes to set from example defaults
:param string err_msg[]: error messages list to append
:return: status and error message list
:rtype: [bool, string[]]
"""
has_kind = True
has_all_attributes = True
all_attributes = []
attributes = {}
kind = Test.search_category({'class': 'kind', 'term': resource, 'scheme': 'http://schemas.ogf.org/occi/infrastructure#'})
#print kind
if not kind:
has_kind = False
err_msg.append('No OCCI Kind found')
if not kind:
return [False, err_msg]
for item in ['location', 'term', 'scheme']:
if item not in kind.keys():
has_kind = False
err_msg.append('No %s in OCCI Kind' % item)
if 'attributes' in kind:
all_attributes += kind['attributes']
if additional_attributes is not None:
all_attributes += additional_attributes
#print 'list of attributes: %s' % repr(all_attributes)
if not get_attributes(all_attributes, attributes, err_msg):
has_all_attributes = False
#print 'list of result attribute keys: %s' % repr(attributes.keys())
new_cat_s, new_cat_h = renderer.render_resource(categories, None, attributes.values())
body, response_request, http_status, content_type = occi_curl(url=kind['location'], headers=['Content-Type: %s' % occi_config['mimetype']] + new_cat_h, post=new_cat_s, custom_request='POST')
check_create, tmp_err_msg = check_http_status("201 Created", http_status)
err_msg += tmp_err_msg
check_ct, tmp_err_msg = check_content_type(content_type)
err_msg += tmp_err_msg
entities = check_body_entities(body, response_request, err_msg)
check_br = (entities is not None and entities)
check_rct, tmp_err_msg = check_requested_content_type(content_type)
err_msg += tmp_err_msg
if not check_create:
print >> sys.stderr, body
Test.clear_categories()
body, response_headers, http_status, content_type = occi_curl(url=kind['location'])
entities2 = check_body_entities(body, response_headers, err_msg)
# check if the entity is really created (just check the first: entities[0])
check_created = False
if entities:
for line in entities2:
if line == entities[0]:
check_created = True
break
if not check_created:
err_msg.append('OCCI %s Resource hasn\'t been successfully created' % resource.title())
return [has_kind and has_all_attributes and check_create and check_created and check_ct and check_br and check_rct and check_created, err_msg]
def test(self=None):
err_msg = []
check_response = True
check, err_msg, urls = CORE_READ_URL(occi_config['occi.tests.category'])
if not urls:
err_msg.append('No OCCI Entity instance found')
return [False, err_msg]
#print urls
url = urls[0]
body, response_headers, http_status, content_type = occi_curl(base_url=url, url='')
categories, links, attributes = renderer.parse_resource(body, response_headers)
# change one attribute
#print attributes
a = None
for a in attributes:
if a['name'] == 'occi.core.title':
break
if a is None or a['name'] != 'occi.core.title':
a = occi.Attribute({'name': 'occi.core.title', 'value': gen_id('c_pOCCI')})
attributes.append(a)
else:
a['value'] = gen_id(a['value'])
body, headers = renderer.render_resource(categories, links, attributes)
# update
body, response_headers, http_status, content_type = occi_curl(base_url=url, url='', headers=['Content-Type: %s' % occi_config['mimetype']] + headers, post=body, custom_request='PUT')
#print body
#print http_status
Test.clear_categories()
check_ct, tmp_err_msg = check_content_type(content_type)
err_msg += tmp_err_msg
if content_type != occi_config['mimetype']:
err_msg += ['Content-Type is not requested "%s"' % occi_config['mimetype']]
check_ct = False
check, tmp_err_msg = check_http_status("200 OK", http_status)
if check:
# response contains OCCI Entity description
response_categories, response_links, response_attributes = renderer.parse_resource(body, response_headers)
if not response_categories or not response_attributes:
err_msg += ['HTTP Response doesn\'t contain categories or attributes']
check_response = False
else:
check, tmp_err_msg = check_http_status("201 Created", http_status)
if check:
response_urls = renderer_httpheaders.parse_locations(None, response_headers)
#print 'Entity URL'
#print 'Response URLs:\n '
#print response_urls
check_response = False
for url in response_urls:
if response_url == url:
check_response = True
if not check_response:
err_msg += ['HTTP Location headers is not OCCI Entity URL (%s)' % response_url]
if not check:
err_msg.append('HTTP status is neither 200 OK nor 201 Created (%s)' % http_status)
print >> sys.stderr, body
return [check and check_ct and check_response, err_msg]
