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