def test_load_parameter_file(self): from biocrnpyler import Parameter import sys from warnings import warn with self.assertRaises(AssertionError): Parameter.load_parameter_file(filename=None) # TODO track down why this test fails in python 3.6! if sys.version_info[1] >= 7: # do NOT reformat this string below example_csv = """mechanism_id part_id param_name param_val comments\ntranscription_mm ptet_tetR kb 10. extra columns are okay!\ntranscription_mm ptet_tetR ku .1 These are the parameters for transcription""" with patch('builtins.open', mock_open(read_data=example_csv), create=True): rtn_dict = Parameter.load_parameter_file(filename='test_file') right_dict = { ('transcription_mm', 'ptet_tetR', 'kb'): 10.0, ('transcription_mm', 'ptet_tetR', 'ku'): 0.1 } self.assertEqual(rtn_dict, right_dict) else: warn('version below 3.6 was detected! This test was skipped')
def test_parameter_initialization(self): from biocrnpyler import Parameter with self.assertRaises(ValueError): Parameter(name='test_param', param_type='Nothing', value=0) with self.assertRaises(AssertionError): Parameter(name='test_param', param_type=[], value=0)
def test_parameter_initialization(self): # test unknown parameter type with self.assertRaisesRegexp(ValueError, "can't parse value of parameter"): Parameter(name='test_param', param_type='Nothing', value=0) # test invalid parameter type with self.assertRaisesRegexp(ValueError, 'parameter_type must be a string'): Parameter(name='test_param', param_type=[], value=0)
def test__get_field_names(self): from biocrnpyler import Parameter with self.assertRaises(AssertionError): Parameter._get_field_names(field_names=None, accepted_field_names=None) with self.assertRaises(AssertionError): Parameter._get_field_names(field_names={}, accepted_field_names={}) accepted_field_names = { 'mechanism': ['mechanism', 'mechanism_id'], 'param_name': ["parameter_name", "parameter", "param", "param_name"], 'part_id': ['part_id', 'part'], 'param_val': ["val", "value", "param_val", "parameter_value"] } ret_dict = Parameter._get_field_names( field_names=[''], accepted_field_names=accepted_field_names) self.assertEqual(accepted_field_names.keys(), ret_dict.keys()) field_names = ['part_id'] with self.assertWarns(Warning): Parameter._get_field_names(field_names, accepted_field_names) accepted_field_names = { 'dummy': ['dumb', 'dumber'], } with self.assertWarns(Warning): Parameter._get_field_names(field_names, accepted_field_names)
def test_create_parameter_dictionary(self): from biocrnpyler import Parameter parameters = Parameter.create_parameter_dictionary(parameters=None, parameter_file=None) self.assertEqual(parameters, None) with self.assertRaises(FileNotFoundError): Parameter.create_parameter_dictionary(parameters={}, parameter_file='dummy_file')
def test_create_parameter_dictionary(self): # test that no parameter dictionary or parameter files are given empty parameter dict is returned empty_dict = {} parameters = Parameter.create_parameter_dictionary(parameters=None, parameter_file=None) self.assertEqual(parameters, empty_dict) # test that no parameter file is given then the supplied parameter dictionary is returned param_dict = {'kb': 10.0} parameters = Parameter.create_parameter_dictionary( parameters=param_dict, parameter_file=None) self.assertEqual(parameters, param_dict) with self.assertRaises(FileNotFoundError): Parameter.create_parameter_dictionary(parameters={}, parameter_file='dummy_file')
def test_parameter(self): # test parameter name with self.assertRaisesRegex(ValueError, f"parameter_name must be a string"): Parameter(parameter_name=None, parameter_value=1.0) # test parameter value with self.assertRaisesRegex(ValueError, f"parameter_value must be a float or int"): Parameter(parameter_name="None", parameter_value=None) # test invalid value string with self.assertRaisesRegex( ValueError, f"No valid parameter value! Accepted format"): Parameter(parameter_name="None", parameter_value='2ba') # test string parameter values self.assertTrue( Parameter(parameter_name="None", parameter_value="1.0").value == 1.0) self.assertTrue( Parameter(parameter_name="None", parameter_value="1/2").value == 0.5) self.assertTrue( Parameter(parameter_name="None", parameter_value="1e2").value == 100) # testing invalid parameter name with self.assertRaisesRegex( ValueError, f"parameter_name should be at least one character and cannot start with a number!" ): Parameter(parameter_name="2", parameter_value=2)
def test_parameter_entry(self): #Valid ParameterEntry Construction #With unit P0 = ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key={"part_id": "id"}, parameter_info={ "comment": "comment", "unit": "M" }) P1 = ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key={"part_id": "id"}, parameter_info={"comment": "comment"}, unit="M") #Without unit P2 = ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key={"part_id": "id"}, parameter_info={"comment": "comment"}) #Assert unit is passed through to Parameter.unit from the parameter_info_dictionary self.assertTrue(P0.unit == "M") self.assertTrue(P1.unit == "M") self.assertTrue(P2.unit == "") #Test duplication of parameter information error with self.assertRaisesRegex(ValueError, "Recieved multiple parameter units"): P0 = ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key={"part_id": "id"}, parameter_info={ "comment": "comment", "unit": "M" }, unit="m") #Invalid keys param_keys = Parameter(parameter_name="None", parameter_value=1.0) with self.assertRaisesRegex(ValueError, "parameter_key must be"): ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key=param_keys) #Invalid info param_info = "blah blah" with self.assertRaisesRegex( ValueError, f"parameter_info must be None or a dictionary"): ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_info=param_info)
def test_model_parameter(self): #valid ModelParameter Construction ModelParameter(parameter_name="None", parameter_value=1.0, search_key=("that", "this", "k"), found_key=("this", None, "k")) #Invalid keys k = Parameter(parameter_name="None", parameter_value="1.0") with self.assertRaisesRegex(ValueError, "parameter_key must be None"): ModelParameter(parameter_name="None", parameter_value=1.0, search_key=k, found_key=("this", None, "k")) with self.assertRaisesRegex(ValueError, "parameter_key must be None"): ModelParameter(parameter_name="None", parameter_value=1.0, search_key=("that", "this", "k"), found_key=k)
def test_parameter_entry(self): #Valid ParameterEntry Construction ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key={"part_id": "id"}, parameter_info={"comment": "comment"}) #Invalid keys param_keys = Parameter(parameter_name="None", parameter_value=1.0) with self.assertRaisesRegex(ValueError, "parameter_key must be"): ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_key=param_keys) #Invalid info param_info = "blah blah" with self.assertRaisesRegex( ValueError, f"parameter_info must be None or a dictionary"): ParameterEntry(parameter_name="None", parameter_value=1.0, parameter_info=param_info)
def test__get_field_names(self): test_accepted_field_names = { 'mechanism': ['mechanism', 'mechanism_id'] } valid_field_names = ['part_id'] # test None as field_names with self.assertRaisesRegexp(ValueError, 'field_names must be a list of strings'): Parameter._get_field_names( field_names=None, accepted_field_names=test_accepted_field_names) # test invalid field_names type with self.assertRaisesRegexp(ValueError, 'field_names must be a list of strings'): Parameter._get_field_names( field_names={}, accepted_field_names=test_accepted_field_names) # test empty field_names list with self.assertRaisesRegexp(ValueError, 'field_names cannot be empty list!'): Parameter._get_field_names( field_names=[], accepted_field_names=test_accepted_field_names) # test None as accepted_field_names with self.assertRaisesRegexp( ValueError, 'accepted_field_names must be a dictionary'): Parameter._get_field_names(field_names=valid_field_names, accepted_field_names=None) # test invalid accepted_field_names type with self.assertRaisesRegexp( ValueError, 'accepted_field_names must be a dictionary'): Parameter._get_field_names(field_names=valid_field_names, accepted_field_names=[]) # test empty field_names list with self.assertRaisesRegexp( ValueError, 'accepted_field_names cannot be empty dictionary'): Parameter._get_field_names(field_names=valid_field_names, accepted_field_names={}) accepted_field_names = { 'mechanism': ['mechanism', 'mechanism_id'], 'param_name': ["parameter_name", "parameter", "param", "param_name"], 'part_id': ['part_id', 'part'], 'param_val': ["val", "value", "param_val", "parameter_value"] } ret_dict = Parameter._get_field_names( field_names=[''], accepted_field_names=accepted_field_names) self.assertEqual(accepted_field_names.keys(), ret_dict.keys()) with self.assertWarns(Warning): Parameter._get_field_names(valid_field_names, accepted_field_names) accepted_field_names = { 'dummy': ['dumb', 'dumber'], } with self.assertWarns(Warning): Parameter._get_field_names(valid_field_names, accepted_field_names)