def test__should_affirm_instance_inequality__when_molecular_formula_instances_have_different_fields(
name: str, element_counts: Dict[str, int]):
formula1 = MolecularFormula(
name=name,
elements={
Element(name=name,
isotopes=[
Isotope(name=name, mass=mass, abundance=abundance)
for name, mass, abundance in element_params[name]
]): count
for name, count in element_counts.items()
})
formula2 = MolecularFormula(
name='CH4',
elements={
Element(name=name,
isotopes=[
Isotope(name=name, mass=mass, abundance=0.5)
for name, mass, abundance in element_params[name]
]): count
for name, count in element_counts.items()
})
assert formula1 != formula2
def test__should_make_function_calls__when_compute_isotope_pattern_is_called():
isotope_formulas = [
IsotopeFormula(
name='formula 1',
isotopes={Isotope(name='', mass=2.0, abundance=0.0): 1},
probability=0.0
),
IsotopeFormula(
name='formula 2',
isotopes={Isotope(name='', mass=1.0, abundance=0.0): 1},
probability=0.0
)
]
with patch.object(
target=api.parser,
attribute='parse'
) as mock_parse_call:
with patch.object(
target=isotope_pattern,
attribute='compute_isotope_pattern'
) as mock_compute_isotope_pattern_call:
mock_compute_isotope_pattern_call.return_value = isotope_formulas
patterns = api.compute_isotope_pattern(formula_string='')
mock_parse_call.assert_called_once()
mock_compute_isotope_pattern_call.assert_called_once()
assert len(patterns) == len(isotope_formulas)
assert patterns == list(reversed(isotope_formulas))
def test__should_affirm_instance_inequality__when_isotope_formula_instances_have_different_fields(
name: str, isotope_counts: Dict[str, int]):
formula1 = IsotopeFormula(
name=name,
isotopes={
Isotope(name=name,
mass=isotope_params[name][0],
abundance=isotope_params[name][1]): count
for name, count in isotope_counts.items()
},
probability=0.0,
)
formula2 = IsotopeFormula(
name='C12[1]H1[4]',
isotopes={
Isotope(name=name,
mass=isotope_params[name][0],
abundance=isotope_params[name][1]): count
for name, count in isotope_counts.items()
},
probability=0.1,
)
assert formula1 != formula2
def isotope_map() -> Dict[str, Isotope]:
return copy.deepcopy({
'C12':
Isotope(name='C12', mass=12.0000000, abundance=0.989),
'C13':
Isotope(name='C13', mass=13.0033548, abundance=0.011),
'H1':
Isotope(name='H1', mass=1.0078250, abundance=1.000),
'O16':
Isotope(name='O16', mass=15.9949146, abundance=0.998),
'O18':
Isotope(name='O18', mass=17.9991596, abundance=0.002)
})
def retrieve_isotopes(raw_isotopes: List[dict]) -> List[Isotope]:
isotopes = list()
for raw_isotope in raw_isotopes:
isotopes.append(
Isotope(name=raw_isotope['name'],
mass=raw_isotope['mass'],
abundance=raw_isotope['abundance']))
return isotopes
def test__should_compute_correct_mass__when_isotope_formula_instance_is_created(
mass_counts: List[Tuple[float, int]], expected_mass: float):
formula = IsotopeFormula(name='',
isotopes={
Isotope(name='', mass=mass, abundance=0.0):
count
for mass, count in mass_counts
},
probability=0.0)
assert formula.mass == expected_mass
def test__should_parse_elements__when_config_file_is_correct(file_path: str):
full_path = path.join('tests', 'data', 'unit', file_path)
settings = Settings.parse_from_file(full_path)
elements = settings.elements
assert len(elements) == 3
assert Element(
name='H',
isotopes=[Isotope(name='H1', mass=1.0078250,
abundance=1.00)]) in elements
assert Element(name='C',
isotopes=[
Isotope(name='C12', mass=12.0, abundance=0.989),
Isotope(name='C13', mass=13.0033548, abundance=0.011)
]) in elements
assert Element(name='O',
isotopes=[
Isotope(name='O16', mass=15.9949146, abundance=0.998),
Isotope(name='O18', mass=17.9991596, abundance=0.002)
]) in elements
def test__should_return_correct_string__when_string_representation_is_invoked(
name: str, element_counts: Dict[str, int]):
formula = MolecularFormula(
name=name,
elements={
Element(name=name,
isotopes=[
Isotope(name=name, mass=mass, abundance=abundance)
for name, mass, abundance in element_params[name]
]): count
for name, count in element_counts.items()
})
assert str(formula) == f'MolecularFormula(name={name})'
def test__should_affirm_instance_inequality__when_comparison_with_another_class(
name: str, element_counts: Dict[str, int]):
formula = MolecularFormula(
name=name,
elements={
Element(name=name,
isotopes=[
Isotope(name=name, mass=mass, abundance=abundance)
for name, mass, abundance in element_params[name]
]): count
for name, count in element_counts.items()
})
assert formula != 1
assert formula != 'str'
assert formula != [1, 2, 3]
def test__should_affirm_instance_inequality__when_comparison_with_another_class(
name: str, isotope_counts: Dict[str, int]):
formula = IsotopeFormula(
name=name,
isotopes={
Isotope(name=name,
mass=isotope_params[name][0],
abundance=isotope_params[name][1]): count
for name, count in isotope_counts.items()
},
probability=0.0,
)
assert formula != 1
assert formula != 'str'
assert formula != [1, 2, 3]
def test__should_return_correct_string__when_string_representation_is_invoked(
name: str, isotope_counts: Dict[str, int]):
formula = IsotopeFormula(
name=name,
isotopes={
Isotope(name=name,
mass=isotope_params[name][0],
abundance=isotope_params[name][1]): count
for name, count in isotope_counts.items()
},
probability=0.25,
)
expected_string = (
f'IsotopeFormula'
f'(name={name}, mass={round(formula.mass, 3)}, probability={round(formula.probability, 3)})'
)
assert str(formula) == expected_string