def test_delete(self):
method = 'test_delete'
rv = self.app.post('/api/goals/association',
content_type='application/json',
data=jsonpickle.encode(self.new_assoc_dict))
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
url = '/api/goals/association/environment/Psychosis/goal/Upload%20clinical%20data%20to%20NeuroGrid/subgoal/Anonymise%20data?session_id=test'
rv = self.app.delete(url)
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
self.assertIsNotNone(json_resp, 'No results after deserialization')
ackMsg = json_resp.get('message', None)
self.assertGreater(ackMsg.find('deleted'), -1,
'Goal association not deleted')
def test_delete(self):
method = 'test_delete'
rv = self.app.post('/api/locations',
content_type='application/json',
data=jsonpickle.encode(self.new_locs_dict))
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
url = '/api/locations/name/%s?session_id=test' % quote(
self.new_locs.theName)
rv = self.app.delete(url)
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
self.assertIsNotNone(json_resp, 'No results after deserialization')
ackMsg = json_resp.get('message', None)
self.assertEqual(ackMsg, 'SturminsterWTW deleted')
def test_put_name(self):
method = 'test_put_name'
rv = self.app.post('/api/assets', content_type='application/json', data=jsonpickle.encode(self.new_asset_dict))
url = '/api/assets/name/%s' % quote(self.new_asset.theName)
upd_asset = self.new_asset
upd_asset.theName = 'Test2'
upd_asset_dict = self.new_asset_dict
upd_asset_dict['object'] = upd_asset
upd_asset_body = jsonpickle.encode(upd_asset_dict)
self.logger.info('[%s] JSON data: %s', method, upd_asset_body)
rv = self.app.put(url, content_type='application/json', data=upd_asset_body)
if (sys.version_info > (3,)):
putResponse = rv.data.decode('utf-8')
else:
putResponse = rv.data
self.logger.debug('[%s] Response data: %s', method, putResponse)
json_resp = json_deserialize(putResponse)
self.assertIsNotNone(json_resp, 'No results after deserialization')
message = json_resp.get('message', None)
self.assertIsNotNone(message, 'No message returned')
rv = self.app.get('/api/assets/name/Test2?session_id=test')
if (sys.version_info > (3,)):
asset = json_deserialize(rv.data.decode('utf-8'))
else:
asset = json_deserialize(rv.data)
self.logger.info('[%s] Asset: %s\n', method, asset['theName'])
def test_delete(self):
method = 'test_delete'
rv = self.app.post('/api/persona_characteristics',
content_type='application/json',
data=json.dumps(self.new_pc_dict))
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
url = '/api/persona_characteristics/name/%s?session_id=test' % quote(
'This is a test characteristic')
rv = self.app.delete(url)
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
self.assertIsNotNone(json_resp, 'No results after deserialization')
ackMsg = json_resp.get('message', None)
self.assertGreater(ackMsg.find('deleted'), -1, 'PC not deleted')
def test_get_all_dimensions_by_environment(self):
method = 'test_get_all_dimensions_by_environment'
url = '/api/dimensions/table/asset/environment/Psychosis?session_id=test'
rv = self.app.get(url)
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
dims = jsonpickle.decode(responseData)
self.assertIsNotNone(dims, 'No results are deserialization')
self.assertGreater(len(dims), 0, 'No dimensions in the dictionary')
self.assertEqual(len(dims), 13,
'Incorrect number of asset names returned')
dimValue = dims[0]
self.logger.info('[%s] First asset: %s\n', method, dimValue)
rv = self.app.get(
'/api/dimensions/table/Foo/environment/Psychosis?session_id=test')
msg = json_deserialize(rv.data)
self.assertEqual(msg['code'], 400)
rv = self.app.get(
'/api/dimensions/table/asset/environment/Foo?session_id=test')
msg = json_deserialize(rv.data)
self.assertEqual(msg['code'], 404)
def test_delete(self):
method = 'test_delete'
rv = self.app.post('/api/template_goals',
content_type='application/json',
data=jsonpickle.encode(self.new_tg_dict))
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
url = '/api/template_goals/name/%s?session_id=test' % quote(
self.new_tg.theName)
rv = self.app.delete(url)
if (sys.version_info > (3, )):
responseData = rv.data.decode('utf-8')
else:
responseData = rv.data
self.logger.debug('[%s] Response data: %s', method, responseData)
json_resp = json_deserialize(responseData)
self.assertIsNotNone(json_resp, 'No results after deserialization')
ackMsg = json_resp.get('message', None)
self.assertGreater(ackMsg.find('deleted'), -1,
'Template goal not deleted')
def test_put_id(self):
method = 'test_put_id'
rv = self.app.post('/api/roles',
content_type='application/json',
data=self.new_role_body)
rv = self.app.get('/api/roles?session_id=test')
roles = json_deserialize(rv.data)
role = roles.get(self.new_role.theName)
url = '/api/roles/id/%d' % role.theId
upd_role = self.new_role
upd_role.theName = 'Test2'
upd_role_dict = self.new_role_dict
upd_role_dict['object'] = upd_role
upd_role_body = jsonpickle.encode(upd_role_dict)
self.logger.info('[%s] JSON data: %s', method, upd_role_body)
rv = self.app.put(url,
content_type='application/json',
data=upd_role_body)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
message = json_resp.get('message', None)
self.assertIsNotNone(message, 'No message returned')
rv = self.app.get('/api/roles/name/Test2?session_id=test')
role = json_deserialize(rv.data)
self.logger.info('[%s] Role: %s [%d]\n', method, role.theName,
role.theId)
def test_get_name(self):
method = 'test_get_name'
url = '/api/assets/name/%s?session_id=test' % quote(self.existing_asset_name)
rv = self.app.get(url)
if (sys.version_info > (3,)):
asset = json_deserialize(rv.data.decode('utf-8'))
else:
asset = json_deserialize(rv.data)
self.assertIsNotNone(asset, 'No results after deserialization')
self.assertEqual(asset['theName'],self.existing_asset_name)
def test_get_invalid_name(self):
method = 'test_get_name'
url = '/api/assets/name/invalidname?session_id=test'
rv = self.app.get(url)
if (sys.version_info > (3,)):
msg = json_deserialize(rv.data.decode('utf-8'))
else:
msg = json_deserialize(rv.data)
self.assertIsNotNone(msg, 'No results after deserialization')
self.assertEqual(msg['code'],404)
def test_get_all_summary(self):
method = 'test_get_all_summary'
rv = self.app.get('/api/goals/summary?session_id=test')
if (sys.version_info > (3,)):
goals = json_deserialize(rv.data.decode('utf-8'))
else:
goals = json_deserialize(rv.data)
self.assertIsNotNone(goals, 'No results after deserialization')
self.assertGreater(len(goals), 0, 'No goal summaries')
self.logger.info('[%s] Goals found: %d', method, len(goals))
self.logger.info('[%s] First goal summary: %s \n', method, goals[0]['theName'])
def test_get_name(self):
method = 'test_get_name'
url = '/api/assets/name/%s?session_id=test' % quote(self.existing_asset_name)
rv = self.app.get(url)
if (sys.version_info > (3,)):
asset = json_deserialize(rv.data.decode('utf-8'))
else:
asset = json_deserialize(rv.data)
self.assertIsNotNone(asset, 'No results after deserialization')
self.assertIsInstance(asset, dict, 'The result is not a dict as expected')
self.logger.info('[%s] Asset: %s\n', method, asset['theName'])
def test_get_all_summary(self):
method = 'test_get_all_summary'
rv = self.app.get('/api/threats/summary?session_id=test')
if (sys.version_info > (3,)):
thrs = json_deserialize(rv.data.decode('utf-8'))
else:
thrs = json_deserialize(rv.data)
self.assertIsNotNone(thrs, 'No results after deserialization')
self.assertGreater(len(thrs), 0, 'No threat summaries')
self.assertIsInstance(thrs[0], dict)
self.logger.info('[%s] Threats found: %d', method, len(thrs))
self.logger.info('[%s] First threat summary: %s [%s]\n', method, thrs[0]['theName'])
def test_get_all_summary(self):
method = 'test_get_all_summary'
rv = self.app.get('/api/persona_characteristics/summary?session_id=test')
if (sys.version_info > (3,)):
pcs = json_deserialize(rv.data.decode('utf-8'))
else:
pcs = json_deserialize(rv.data)
self.assertIsNotNone(pcs, 'No results after deserialization')
self.assertGreater(len(pcs), 0, 'No persona characteristics summaries')
self.assertIsInstance(pcs[0], dict)
self.logger.info('[%s] Persona characteristics found: %d', method, len(pcs))
self.logger.info('[%s] First persona characteristic summary: %s', method, pcs[0]['theName'])
def test_get_all_summary(self):
method = 'test_get_all_summary'
rv = self.app.get('/api/assets/summary?session_id=test')
if (sys.version_info > (3,)):
assets = json_deserialize(rv.data.decode('utf-8'))
else:
assets = json_deserialize(rv.data)
self.assertIsNotNone(assets, 'No results after deserialization')
self.assertGreater(len(assets), 0, 'No asset summaries')
self.assertIsInstance(assets[0], ObjectSummary)
self.logger.info('[%s] Assets found: %d', method, len(assets))
self.logger.info('[%s] First asset summary: %s [%d]\n', method, assets[0].theName, assets[0].theType)
def test_get_all_summary(self):
method = 'test_get_all_summary'
rv = self.app.get('/api/usecases/summary?session_id=test')
if (sys.version_info > (3, )):
ucs = json_deserialize(rv.data.decode('utf-8'))
else:
ucs = json_deserialize(rv.data)
self.assertIsNotNone(ucs, 'No results after deserialization')
self.assertGreater(len(ucs), 0, 'No goal summaries')
self.assertIsInstance(ucs[0], ObjectSummary)
self.logger.info('[%s] Use Cases found: %d', method, len(ucs))
self.logger.info('[%s] First use case summary: %s [%s]\n', method,
ucs[0].theName)
def test_get_all(self):
method = 'test_get_all'
rv = self.app.get('/api/assets?session_id=test')
if (sys.version_info > (3,)):
assets = json_deserialize(rv.data.decode('utf-8'))
else:
assets = json_deserialize(rv.data)
self.assertIsNotNone(assets, 'No results after deserialization')
self.assertIsInstance(assets, dict, 'The result is not a dictionary as expected')
self.assertGreater(len(assets), 0, 'No assets in the dictionary')
self.assertIsInstance(list(assets.values())[0], dict)
self.logger.info('[%s] Assets found: %d', method, len(assets))
self.logger.info('[%s] First asset: %s\n', method, list(assets.values())[0]['theName'])
def test_post(self):
method = 'test_post_new'
rv = self.app.post('/api/assets',
content_type='application/json',
data=jsonpickle.encode(self.new_asset_dict))
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
asset_id = json_resp.get('asset_id', None)
self.assertIsNotNone(asset_id, 'No asset ID returned')
rv = self.app.get('/api/assets/id/%d?session_id=test' % asset_id)
asset = json_deserialize(rv.data)
self.logger.info('[%s] Asset: %s [%d]\n', method, asset.theName,
asset.theId)
def test_delete(self):
method = 'test_delete'
rv = self.app.post('/api/document_references', content_type='application/json', data=jsonpickle.encode(self.new_dr_dict))
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
url = '/api/document_references/name/%s?session_id=test' % quote(self.new_dr.theName)
rv = self.app.delete(url)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
ackMsg = json_resp.get('message', None)
self.assertEqual(ackMsg, 'Document Reference successfully deleted')
def from_json(self, request, domain_name=None):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, RequirementModel.required)
json_dict[
'__python_obj__'] = Requirement.__module__ + '.' + Requirement.__name__
json_dict['attrs'] = {}
json_dict['dirtyAttrs'] = {}
json_dict['theVersion'] = -1
json_dict['attrs']['originator'] = json_dict['theOriginator']
json_dict['attrs']['supportingMaterial'] = ''
json_dict['attrs']['fitCriterion'] = json_dict['theFitCriterion']
if (domain_name != None):
json_dict['attrs']['asset'] = domain_name
else:
json_dict['attrs']['asset'] = json_dict['theDomain']
json_dict['attrs']['rationale'] = json_dict['theRationale']
json_dict['attrs']['type'] = json_dict['theType']
requirement = json_serialize(json_dict)
requirement = json_deserialize(requirement)
if not isinstance(requirement, Requirement):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
requirement.theAsset = json_dict['attrs']['asset']
return requirement
def from_json(self, request):
"""
:rtype : Countermeasure
:raise MalformedJSONHTTPError:
"""
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, CountermeasureModel.required)
json_dict['__python_obj__'] = Countermeasure.__module__ + '.' + Countermeasure.__name__
countermeasure_props = self.convert_props(fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
countermeasure = json_serialize(json_dict)
countermeasure = json_deserialize(countermeasure)
countermeasure.theEnvironmentProperties = countermeasure_props
if not isinstance(countermeasure, Countermeasure):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return countermeasure
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TemplateAssetModel.required)
json_dict[
'__python_obj__'] = TemplateAsset.__module__ + '.' + TemplateAsset.__name__
ifs = json_dict.pop('theInterfaces', [])
ifs = self.convert_ifs(fake_ifs=ifs)
props = json_dict.pop('theProperties', [])
ta = json_serialize(json_dict)
props, rats = self.convert_props(fake_props=props)
ta = json_deserialize(ta)
if isinstance(ta, TemplateAsset):
ta.theInterfaces = ifs
ta.theProperties = props
ta.theRationale = rats
return ta
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, DataFlowModel.required)
json_dict[
'__python_obj__'] = DataFlow.__module__ + '.' + DataFlow.__name__
realDfos = []
for dfo in json_dict['theObstacles']:
check_required_keys(dfo, DataFlowObstacle.required)
realDfos.append(
(dfo['theObstacleName'], dfo['theKeyword'], dfo['theContext']))
dataflow = json_serialize(json_dict)
dataflow = json_deserialize(dataflow)
dataflow.theObstacles = realDfos
if not isinstance(dataflow, DataFlow):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return dataflow
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, UseCaseModel.required)
json_dict[
'__python_obj__'] = UseCase.__module__ + '.' + UseCase.__name__
usecase_props = self.convert_props(
fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
usecase = json_serialize(json_dict)
usecase = json_deserialize(usecase)
usecase.theEnvironmentProperties = usecase_props
if not isinstance(usecase, UseCase):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
frcs = json_dict['theReferenceContributions']
refContribs = []
for frc in frcs:
refContribs.append(
ReferenceContribution(
usecase.theName, frc['theContributionTo'],
frc['theReferenceContribution']['theMeansEnd'],
frc['theReferenceContribution']['theContribution']))
return usecase, refContribs
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, VulnerabilityModel.required)
json_dict[
'__python_obj__'] = Vulnerability.__module__ + '.' + Vulnerability.__name__
for idx in range(0, len(json_dict['theEnvironmentProperties'])):
property = json_dict['theEnvironmentProperties'][idx]
check_required_keys(
property, VulnerabilityEnvironmentPropertiesModel.required)
property[
'__python_obj__'] = VulnerabilityEnvironmentProperties.__module__ + '.' + VulnerabilityEnvironmentProperties.__name__
json_dict['theEnvironmentProperties'][idx] = property
vulnerability = json_serialize(json_dict)
vulnerability = json_deserialize(vulnerability)
if not isinstance(vulnerability, Vulnerability):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return vulnerability
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, RiskModel.required)
json_dict[
'__python_obj__'] = RiskParameters.__module__ + '.' + RiskParameters.__name__
if json_dict['theMisuseCase']:
mc_dict = json_dict['theMisuseCase']
check_required_keys(mc_dict, MisuseCaseModel.required)
mc_dict[
'__python_obj__'] = MisuseCaseParameters.__module__ + '.' + MisuseCaseParameters.__name__
for idx in range(0, len(mc_dict['theEnvironmentProperties'])):
mcep_dict = mc_dict['theEnvironmentProperties'][idx]
check_required_keys(
mcep_dict, MisuseCaseEnvironmentPropertiesModel.required)
mcep_dict[
'__python_obj__'] = MisuseCaseEnvironmentProperties.__module__ + '.' + MisuseCaseEnvironmentProperties.__name__
mc_dict['theEnvironmentProperties'][idx] = mcep_dict
json_dict['theMisuseCase'] = mc_dict
risk = json_deserialize(json_dict)
if isinstance(risk, RiskParameters):
return risk
else:
raise MalformedJSONHTTPError()
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, LocationsModel.required)
json_dict[
'__python_obj__'] = Locations.__module__ + '.' + Locations.__name__
loc_list = self.convert_loc_list(
fake_loc_list=json_dict['theLocations'])
json_dict['theLocations'] = []
locs = json_serialize(json_dict)
locs = json_deserialize(locs)
locs.theLocations = loc_list
locs.theLinks = []
if isinstance(locs, Locations):
return locs
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
"""
:rtype : TrustBoundary
:raise MalformedJSONHTTPError:
"""
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, TrustBoundaryModel.required)
json_dict[
'__python_obj__'] = TrustBoundary.__module__ + '.' + TrustBoundary.__name__
env_props = self.convert_props(
fake_props=json_dict['theEnvironmentProperties'])
json_dict['theEnvironmentProperties'] = []
tb = json_serialize(json_dict)
tb = json_deserialize(tb)
tb.theEnvironmentProperties = env_props
if not isinstance(tb, TrustBoundary):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return tb
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, ResponseModel.required)
json_dict[
'__python_obj__'] = Response.__module__ + '.' + Response.__name__
property_dict = json_dict['theEnvironmentProperties']
try:
real_props = self.convert_props(
fake_props=property_dict,
response_type=json_dict['theResponseType'])
json_dict['theEnvironmentProperties'] = real_props
json_resp = json_serialize(json_dict)
response = json_deserialize(json_resp)
if isinstance(response, Response):
return response
else:
raise MalformedJSONHTTPError()
except MalformedJSONHTTPError as ex:
self.close()
raise ex
def from_json(self, request, to_props=False):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
check_required_keys(json_dict, AssetModel.required)
env_props = json_dict.pop('theEnvironmentProperties', [])
env_props = self.convert_props(fake_props=env_props)
ifs = json_dict.pop('theInterfaces',[])
ifs = self.convert_ifs(fake_ifs=ifs)
json_dict.pop('theEnvironmentDictionary', None)
json_dict.pop('theAssetPropertyDictionary', None)
# asset = json_serialize(json_dict)
asset = json_dict
asset['__python_obj__'] = Asset.__module__+'.'+Asset.__name__
asset = json_deserialize(asset)
if isinstance(asset, Asset):
asset.theInterfaces = ifs
asset.theEnvironmentProperties = env_props
return asset
else:
self.close()
raise MalformedJSONHTTPError()
def from_json(self, request):
json = request.get_json(silent=True)
if json is False or json is None:
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
json_dict = json['object']
assert isinstance(json_dict, dict)
check_required_keys(json_dict, EnvironmentModel.required)
json_dict['__python_obj__'] = Environment.__module__+'.'+Environment.__name__
if json_dict.has_key('theTensions'):
assert isinstance(json_dict['theTensions'], list)
tensions = json_dict['theTensions']
json_dict['theTensions'] = {}
for tension in tensions:
check_required_keys(tension, EnvironmentTensionModel.required)
key = tuple([tension['base_attr_id'], tension['attr_id']])
value = tuple([tension['value'], tension['rationale']])
json_dict['theTensions'][key] = value
new_json_environment = json_serialize(json_dict)
environment = json_deserialize(new_json_environment)
if not isinstance(environment, Environment):
self.close()
raise MalformedJSONHTTPError(data=request.get_data())
else:
return environment
