def test_bond_breaking_needs_other_atom(self, mock_bonds):
atom1 = Atom("C", 2, 3, 5)
bond = Mock(Bond)
bond.atoms.return_value = set([atom1, Mock()])
mock_bonds.return_value = set([bond])
with self.assertRaises(ValueError):
atom1.unbond_from(atom1)
def test_can_rotate_in_degrees(self, mock_trim, mock_loc, mock_matrix):
matrix = Mock()
mock_matrix.return_value = matrix
matrix.dot.return_value = [10, 20, 30]
atom = Atom("C", 1, 1, 1)
atom.rotate(90, "x", degrees=True)
mock_matrix.assert_called_with(math.pi / 2, "x")
def test_can_translate_atoms_with_iterable(self, mock_trim):
atom = Atom("C", 20, 30, 50)
atom.translate((5, -4, 12))
self.assertEqual(atom._x, 25)
self.assertEqual(atom._y, 26)
self.assertEqual(atom._z, 62)
mock_trim.assert_called_with(12)
def test_can_rotate_no_trim(self, mock_trim, mock_loc, mock_matrix):
matrix = Mock()
mock_matrix.return_value = matrix
matrix.dot.return_value = [10, 20, 30]
atom = Atom("C", 1, 1, 1)
atom.rotate(9, "x", trim=None)
mock_trim.assert_called_with(None)
def test_can_generate_rotation_matrix_z(self):
atom = Atom("C")
matrix = atom.generate_rotation_matrix(math.pi / 2, "z")
self.assertEqual([[round(val, 12) for val in row] for row in matrix],
[[0, -1, 0], [1, 0, 0], [0, 0, 1]])
matrix = atom.generate_rotation_matrix(math.pi / -36, "z")
self.assertEqual([[round(val, 3) for val in row] for row in matrix],
[[0.996, 0.087, 0], [-0.087, 0.996, 0], [0, 0, 1]])
def test_can_generate_rotation_matrix_y(self):
atom = Atom("C")
matrix = atom.generate_rotation_matrix(math.pi / 2, "y")
self.assertEqual([[round(val, 12) for val in row] for row in matrix],
[[0, 0, 1], [0, 1, 0], [-1, 0, 0]])
matrix = atom.generate_rotation_matrix(math.pi / 18, "y")
self.assertEqual([[round(val, 3) for val in row] for row in matrix],
[[0.985, 0, 0.174], [0, 1, 0], [-0.174, 0, 0.985]])
def test_can_generate_rotation_matrix_x(self):
atom = Atom("C")
matrix = atom.generate_rotation_matrix(math.pi / 2, "x")
self.assertEqual([[round(val, 12) for val in row] for row in matrix],
[[1, 0, 0], [0, 0, -1], [0, 1, 0]])
matrix = atom.generate_rotation_matrix(math.pi / -4, "x")
self.assertEqual([[round(val, 3) for val in row] for row in matrix],
[[1, 0, 0], [0, 0.707, 0.707], [0, -0.707, 0.707]])
def test_can_get_nearby_atoms(self, mock_loc):
model = Mock()
mock_loc.return_value = (1, 2, 3)
atom = Atom("C", 4, 8, 3)
atom._model = model
model.atoms_in_sphere.return_value = [1, 2, atom, 4]
atoms = atom.nearby_atoms(4, a=1, b=2)
model.atoms_in_sphere.assert_called_with(1, 2, 3, 4, a=1, b=2)
self.assertEqual(atoms, [1, 2, 4])
def test_bond_unbreaking_needs_actual_bond(self, mock_bonds):
atom1 = Atom("C", 2, 3, 5)
atom2 = Mock(Atom)
bond = Mock(Bond)
bond.atoms.return_value = set([atom1, Mock(Atom)])
mock_bonds.return_value = set([bond])
atom2.bonds.return_value = set([bond])
with self.assertRaises(ValueError):
atom1.unbond_from(atom2)
def test_can_break_bond_between_atoms(self, mock_bonds):
atom1 = Atom("C", 2, 3, 5)
atom2 = Mock(Atom)
bond = Mock(Bond)
bond.atoms.return_value = set([atom1, atom2])
mock_bonds.return_value = set([bond])
atom2.bonds.return_value = set([bond])
atom1.unbond_from(atom2)
bond.destroy.assert_called_with()
def test_can_get_bonded_atoms(self, mock_bonds):
atom = Atom("C", 2, 3, 5)
bond1, bond2, bond3 = Mock(Bond), Mock(Bond), Mock(Bond)
atom2, atom3, atom4 = Mock(Atom), Mock(Atom), Mock(Atom)
bond1.atoms.return_value = set([atom, atom2])
bond2.atoms.return_value = set([atom, atom3])
bond3.atoms.return_value = set([atom, atom4])
mock_bonds.return_value = set([bond1, bond2, bond3])
self.assertEqual(atom.bonded_atoms(), set([atom2, atom3, atom4]))
def test_atom_mass_case_insensitive(self):
atom = Atom("he", 2, 3, 5)
self.assertAlmostEqual(atom.mass, 4, delta=0.1)
atom = Atom("He", 2, 3, 5)
self.assertAlmostEqual(atom.mass, 4, delta=0.1)
atom = Atom("hE", 2, 3, 5)
self.assertAlmostEqual(atom.mass, 4, delta=0.1)
atom = Atom("HE", 2, 3, 5)
self.assertAlmostEqual(atom.mass, 4, delta=0.1)
def test_coordinates_must_be_numeric(self):
atom = Atom("C", 20, 30, 50)
with self.assertRaises(TypeError):
atom.move_to(1, 2, "3")
with self.assertRaises(TypeError):
atom.move_to(1, "2", 3)
with self.assertRaises(TypeError):
atom.move_to("1", 2, 3)
atom.move_to(1.1, 2.1, 3.1)
def test_can_rotate(self, mock_trim, mock_loc, mock_matrix):
matrix = Mock()
mock_matrix.return_value = matrix
matrix.dot.return_value = [10, 20, 30]
mock_loc.return_value = (0.1, 0.2, 0.3)
atom = Atom("C", 1, 1, 1)
atom.rotate(9, "x")
mock_matrix.assert_called_with(9, "x")
mock_loc.assert_called_with()
matrix.dot.assert_called_with((0.1, 0.2, 0.3))
self.assertEqual(atom._x, 10)
self.assertEqual(atom._y, 20)
self.assertEqual(atom._z, 30)
mock_trim.assert_called_with(12)
def test_can_get_bond_with_atom(self, mock_bonds):
atom1 = Atom("C", 2, 3, 5)
atom2 = Mock(Atom)
atom3 = Mock(Atom)
atom4 = Mock(Atom)
bonda = Mock(Bond)
bondb = Mock(Bond)
bonda.atoms.return_value = set([atom1, atom2])
bondb.atoms.return_value = set([atom1, atom3])
mock_bonds.return_value = set([bonda, bondb])
self.assertIs(atom1.bond_with(atom2), bonda)
self.assertIs(atom1.bond_with(atom3), bondb)
self.assertIs(atom1.bond_with(atom4), None)
self.assertIs(atom1.bond_with(atom1), None)
def setUp(self):
self.atoms = [
Atom("C", 2, 3, 5, name="CA", id=15, charge=1),
Atom("C", 2, 3, 5, name="CA", id=16, charge=1),
Atom("P", 2, 3, 5, name="PB", id=17, charge=1),
Atom("H", 2, 3, 5, name="H1", id=18, charge=1),
Atom("ZN", 2, 3, 5, name="ZN", id=19, charge=1)
]
self.atoms[0]._residue, self.atoms[1]._residue = "H", "H"
def func(a, b, c=20):
return self.atoms
self.func = atom_query(func)
def test_can_make_atom_copy(self):
atom = Atom("he", 2, 3, 5, 10, "H1", 0.5, 0.4)
copy = atom.copy()
self.assertIsInstance(atom, Atom)
self.assertIsNot(atom, copy)
self.assertEqual(copy._element, "he")
self.assertEqual(copy._x, 2)
self.assertEqual(copy._y, 3)
self.assertEqual(copy._z, 5)
self.assertEqual(copy._id, 10)
self.assertEqual(copy._name, "H1")
self.assertEqual(copy._charge, 0.5)
self.assertEqual(copy._bfactor, 0.4)
self.assertEqual(copy._bonds, set())
self.assertEqual(copy._residue, None)
self.assertEqual(copy._chain, None)
self.assertEqual(copy._molecule, None)
self.assertEqual(copy._model, None)
def test_can_create_atom(self):
atom = Atom("C")
self.assertEqual(atom._element, "C")
self.assertEqual(atom._x, 0)
self.assertEqual(atom._y, 0)
self.assertEqual(atom._z, 0)
self.assertEqual(atom._id, 0)
self.assertEqual(atom._name, None)
self.assertEqual(atom._charge, 0)
self.assertEqual(atom._bfactor, 0)
self.assertEqual(atom._bonds, set())
self.assertEqual(atom._residue, None)
self.assertEqual(atom._chain, None)
self.assertEqual(atom._molecule, None)
self.assertEqual(atom._model, None)
self.assertEqual(atom._complex, None)
def test_atom_repr(self):
atom = Atom("C", 2, 3, 5, id=15)
self.assertEqual(str(atom), "<C Atom 15 at (2, 3, 5)>")
def test_atom_bfactor_must_be_number(self):
with self.assertRaises(TypeError):
Atom("C", 2, 3, 5, bfactor="20.5")
Atom("C", 2, 3, 5, bfactor=10)
Atom("C", 2, 3, 5, bfactor=-3)
def test_can_create_atom_with_bfactor(self):
atom = Atom("C", 2, 3, 5, bfactor=2.5)
self.assertEqual(atom._bfactor, 2.5)
def test_atom_charge_must_be_number(self):
with self.assertRaises(TypeError):
Atom("C", 2, 3, 5, charge="20.5")
Atom("C", 2, 3, 5, charge=10)
def test_can_create_atom_with_charge(self):
atom = Atom("C", 2, 3, 5, charge=-2.5)
self.assertEqual(atom._charge, -2.5)
def test_atom_name_must_be_str(self):
with self.assertRaises(TypeError):
Atom("C", 2, 3, 5, name=20.5)
def test_can_create_atom_with_name(self):
atom = Atom("C", 2, 3, 5, name="CA")
self.assertEqual(atom._name, "CA")
def test_id_must_be_integer(self):
with self.assertRaises(TypeError):
Atom("C", 2, 3, 5, id=20.5)
def test_atom_with_no_model_has_no_nearby_atoms(self):
atom = Atom("C", 4, 8, 3)
self.assertEqual(atom.nearby_atoms(cutoff=1), set())
self.assertEqual(atom.nearby_atoms(cutoff=100), set())
def test_element_property(self):
atom = Atom("C", 2, 3, 5)
self.assertIs(atom._element, atom.element)
def test_can_update_element(self):
atom = Atom("C", 2, 3, 5)
atom.element = "N"
self.assertEqual(atom._element, "N")
def test_bond_with_needs_atom(self):
atom1 = Atom("C", 2, 3, 5)
with self.assertRaises(TypeError):
atom1.bond_with("atom2")
