refactor: replace Logger with RunLogger and streamline logging setup
This commit is contained in:
@@ -1,643 +0,0 @@
|
||||
from diceplayer import logger
|
||||
from diceplayer.config.player_config import PlayerConfig
|
||||
from diceplayer.environment import Atom, Molecule, System
|
||||
from diceplayer.interface import DiceInterface
|
||||
from tests.mocks.mock_inputs import get_config_example
|
||||
from tests.mocks.mock_proc import MockConnection, MockProc
|
||||
|
||||
import yaml
|
||||
|
||||
import io
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
|
||||
class TestDiceInterface(unittest.TestCase):
|
||||
def setUp(self):
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
config = yaml.load(get_config_example(), Loader=yaml.Loader)
|
||||
self.config = PlayerConfig.model_validate(config["diceplayer"])
|
||||
|
||||
def test_class_instantiation(self):
|
||||
dice = DiceInterface()
|
||||
|
||||
self.assertIsInstance(dice, DiceInterface)
|
||||
|
||||
def test_configure(self):
|
||||
dice = DiceInterface()
|
||||
|
||||
self.assertIsNone(dice.step)
|
||||
self.assertIsNone(dice.system)
|
||||
|
||||
# Ignoring the types for testing purposes
|
||||
dice.configure(self.config, System())
|
||||
|
||||
self.assertIsNotNone(dice.step)
|
||||
self.assertIsNotNone(dice.system)
|
||||
|
||||
def test_reset(self):
|
||||
dice = DiceInterface()
|
||||
|
||||
dice.configure(self.config, System())
|
||||
|
||||
self.assertTrue(hasattr(dice, "step"))
|
||||
self.assertTrue(hasattr(dice, "system"))
|
||||
|
||||
dice.reset()
|
||||
|
||||
self.assertFalse(hasattr(dice, "step"))
|
||||
self.assertFalse(hasattr(dice, "system"))
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.Process", MockProc())
|
||||
@mock.patch("diceplayer.interface.dice_interface.connection", MockConnection)
|
||||
def test_start(self):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.start(1)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.connection", MockConnection)
|
||||
@mock.patch("diceplayer.interface.dice_interface.Process", MockProc(exitcode=1))
|
||||
def test_start_with_process_error(self):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
with self.assertRaises(SystemExit):
|
||||
dice.start(1)
|
||||
|
||||
def test_simulation_process_raises_exception(self):
|
||||
dice = DiceInterface()
|
||||
|
||||
with self.assertRaises(SystemExit):
|
||||
dice._simulation_process(1, 1)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.DiceInterface._make_proc_dir")
|
||||
@mock.patch("diceplayer.interface.dice_interface.DiceInterface._make_dice_inputs")
|
||||
@mock.patch("diceplayer.interface.dice_interface.DiceInterface._run_dice")
|
||||
def test_simulation_process(
|
||||
self, mock_run_dice, mock_make_dice_inputs, mock_make_proc_dir
|
||||
):
|
||||
dice = DiceInterface()
|
||||
|
||||
dice._simulation_process(1, 1)
|
||||
|
||||
self.assertTrue(dice._make_proc_dir.called)
|
||||
self.assertTrue(dice._make_dice_inputs.called)
|
||||
self.assertTrue(dice._run_dice.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.mkdir")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists")
|
||||
def test_make_proc_dir_if_simdir_exists(self, mock_path_exists, mock_path_mkdir):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
mock_path_exists.return_value = False
|
||||
|
||||
dice._make_proc_dir(1, 1)
|
||||
|
||||
self.assertEqual(mock_path_mkdir.call_count, 2)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.mkdir")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists")
|
||||
def test_make_proc_dir_if_simdir_doesnt_exists(
|
||||
self, mock_path_exists, mock_path_mkdir
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
mock_path_exists.return_value = False
|
||||
|
||||
dice._make_proc_dir(1, 1)
|
||||
|
||||
self.assertEqual(mock_path_mkdir.call_count, 2)
|
||||
|
||||
def test_make_dice_seed(self):
|
||||
seed = DiceInterface._make_dice_seed()
|
||||
|
||||
self.assertIsInstance(seed, int)
|
||||
|
||||
def test_make_dice_inputs_nstep_len_two_with_randoninit_first_cycle_one(self):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.step.dice.nstep = [1, 1]
|
||||
|
||||
dice._make_potentials = mock.Mock()
|
||||
|
||||
dice._make_init_file = mock.Mock()
|
||||
dice._new_density = mock.Mock()
|
||||
|
||||
dice._make_nvt_ter = mock.Mock()
|
||||
dice._make_nvt_eq = mock.Mock()
|
||||
dice._make_npt_ter = mock.Mock()
|
||||
dice._make_npt_eq = mock.Mock()
|
||||
|
||||
dice._make_dice_inputs(1, 1)
|
||||
|
||||
self.assertTrue(dice._make_potentials.called)
|
||||
|
||||
self.assertFalse(dice._make_init_file.called)
|
||||
self.assertFalse(dice._new_density.called)
|
||||
|
||||
self.assertTrue(dice._make_nvt_ter.called)
|
||||
self.assertTrue(dice._make_nvt_eq.called)
|
||||
|
||||
self.assertFalse(dice._make_npt_ter.called)
|
||||
self.assertFalse(dice._make_npt_eq.called)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open, read_data="test")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists", return_value=True)
|
||||
def test_make_dice_inputs_nstep_len_two_with_randoninit_first_cycle_two(
|
||||
self, mock_path_exists, mock_open
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.step.dice.nstep = [1, 1]
|
||||
|
||||
dice._make_potentials = mock.Mock()
|
||||
|
||||
dice._make_init_file = mock.Mock()
|
||||
dice._new_density = mock.Mock()
|
||||
|
||||
dice._make_nvt_ter = mock.Mock()
|
||||
dice._make_nvt_eq = mock.Mock()
|
||||
dice._make_npt_ter = mock.Mock()
|
||||
dice._make_npt_eq = mock.Mock()
|
||||
|
||||
dice._make_dice_inputs(2, 1)
|
||||
|
||||
self.assertTrue(dice._make_potentials.called)
|
||||
|
||||
self.assertTrue(dice._make_init_file.called)
|
||||
self.assertTrue(dice._new_density.called)
|
||||
|
||||
self.assertFalse(dice._make_nvt_ter.called)
|
||||
self.assertTrue(dice._make_nvt_eq.called)
|
||||
|
||||
self.assertFalse(dice._make_npt_ter.called)
|
||||
self.assertFalse(dice._make_npt_eq.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists", return_value=False)
|
||||
def test_make_dice_inputs_raises_exception_on_last_not_found(
|
||||
self, mock_path_exists
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.step.dice.nstep = [1, 1]
|
||||
|
||||
dice._make_potentials = mock.Mock()
|
||||
|
||||
dice._make_init_file = mock.Mock()
|
||||
dice._new_density = mock.Mock()
|
||||
|
||||
dice._make_nvt_ter = mock.Mock()
|
||||
dice._make_nvt_eq = mock.Mock()
|
||||
dice._make_npt_ter = mock.Mock()
|
||||
dice._make_npt_eq = mock.Mock()
|
||||
|
||||
with self.assertRaises(FileNotFoundError):
|
||||
dice._make_dice_inputs(2, 1)
|
||||
|
||||
def test_make_dice_inputs_nstep_len_three_with_randoninit_first_cycle_one(self):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice._make_potentials = mock.Mock()
|
||||
|
||||
dice._make_init_file = mock.Mock()
|
||||
dice._new_density = mock.Mock()
|
||||
|
||||
dice._make_nvt_ter = mock.Mock()
|
||||
dice._make_nvt_eq = mock.Mock()
|
||||
dice._make_npt_ter = mock.Mock()
|
||||
dice._make_npt_eq = mock.Mock()
|
||||
|
||||
dice._make_dice_inputs(1, 1)
|
||||
|
||||
self.assertTrue(dice._make_potentials.called)
|
||||
|
||||
self.assertFalse(dice._make_init_file.called)
|
||||
self.assertFalse(dice._new_density.called)
|
||||
|
||||
self.assertTrue(dice._make_nvt_ter.called)
|
||||
self.assertFalse(dice._make_nvt_eq.called)
|
||||
|
||||
self.assertTrue(dice._make_npt_ter.called)
|
||||
self.assertTrue(dice._make_npt_eq.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.os")
|
||||
@mock.patch("diceplayer.interface.dice_interface.shutil")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists", return_value=True)
|
||||
def test_run_dice_on_first_cycle_run_successful(
|
||||
self, mock_path_exists, mock_shutils, mock_os
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.step.dice.nstep = [1, 1, 1]
|
||||
|
||||
dice.run_dice_file = mock.Mock()
|
||||
|
||||
dice._run_dice(1, 1)
|
||||
|
||||
self.assertTrue(mock_os.getcwd.called)
|
||||
self.assertTrue(mock_os.chdir.called)
|
||||
|
||||
self.assertEqual(dice.run_dice_file.call_count, 3)
|
||||
self.assertTrue(mock_shutils.copy.called)
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.step.dice.nstep = [1, 1]
|
||||
|
||||
dice.run_dice_file = mock.Mock()
|
||||
|
||||
dice._run_dice(1, 1)
|
||||
|
||||
self.assertTrue(mock_os.getcwd.called)
|
||||
self.assertTrue(mock_os.chdir.called)
|
||||
|
||||
self.assertEqual(dice.run_dice_file.call_count, 2)
|
||||
self.assertTrue(mock_shutils.copy.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.os")
|
||||
@mock.patch("diceplayer.interface.dice_interface.shutil")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists", return_value=True)
|
||||
def test_run_dice_on_second_cycle_run_successful(
|
||||
self, mock_path_exists, mock_shutils, mock_os
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.run_dice_file = mock.Mock()
|
||||
|
||||
dice._run_dice(2, 1)
|
||||
|
||||
self.assertTrue(mock_os.getcwd.called)
|
||||
self.assertTrue(mock_os.chdir.called)
|
||||
|
||||
self.assertEqual(dice.run_dice_file.call_count, 2)
|
||||
self.assertTrue(mock_shutils.copy.called)
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.run_dice_file = mock.Mock()
|
||||
|
||||
dice._run_dice(2, 1)
|
||||
|
||||
self.assertTrue(mock_os.getcwd.called)
|
||||
self.assertTrue(mock_os.chdir.called)
|
||||
|
||||
self.assertEqual(dice.run_dice_file.call_count, 2)
|
||||
self.assertTrue(mock_shutils.copy.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.os")
|
||||
@mock.patch("diceplayer.interface.dice_interface.shutil")
|
||||
@mock.patch("diceplayer.interface.dice_interface.Path.exists", return_value=False)
|
||||
def test_run_dice_raises_filenotfound_on_invalid_file(
|
||||
self, mock_path_exists, mock_shutils, mock_os
|
||||
):
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.run_dice_file = mock.Mock()
|
||||
|
||||
with self.assertRaises(FileNotFoundError):
|
||||
dice._run_dice(1, 1)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
def test_make_init_file(self, mock_open):
|
||||
example_atom = Atom(
|
||||
lbl=1,
|
||||
na=1,
|
||||
rx=1.0,
|
||||
ry=1.0,
|
||||
rz=1.0,
|
||||
chg=1.0,
|
||||
eps=1.0,
|
||||
sig=1.0,
|
||||
)
|
||||
|
||||
main_molecule = Molecule("main_molecule")
|
||||
main_molecule.add_atom(example_atom)
|
||||
|
||||
secondary_molecule = Molecule("secondary_molecule")
|
||||
secondary_molecule.add_atom(example_atom)
|
||||
|
||||
system = System()
|
||||
system.add_type(main_molecule)
|
||||
system.add_type(secondary_molecule)
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, system)
|
||||
|
||||
dice.step.dice.nmol = [1, 1]
|
||||
|
||||
last_xyz_file = io.StringIO()
|
||||
last_xyz_file.writelines(
|
||||
[
|
||||
" TEST\n",
|
||||
" Configuration number : TEST = TEST TEST TEST\n",
|
||||
" H 1.00000 1.00000 1.00000\n",
|
||||
" H 1.00000 1.00000 1.00000\n",
|
||||
]
|
||||
)
|
||||
last_xyz_file.seek(0)
|
||||
|
||||
dice._make_init_file("test", last_xyz_file)
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
" 1.000000 1.000000 1.000000\n",
|
||||
" 1.000000 1.000000 1.000000\n",
|
||||
"$end",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
def test_new_density(self, mock_open):
|
||||
example_atom = Atom(
|
||||
lbl=1,
|
||||
na=1,
|
||||
rx=1.0,
|
||||
ry=1.0,
|
||||
rz=1.0,
|
||||
chg=1.0,
|
||||
eps=1.0,
|
||||
sig=1.0,
|
||||
)
|
||||
|
||||
main_molecule = Molecule("main_molecule")
|
||||
main_molecule.add_atom(example_atom)
|
||||
|
||||
secondary_molecule = Molecule("secondary_molecule")
|
||||
secondary_molecule.add_atom(example_atom)
|
||||
|
||||
system = System()
|
||||
system.add_type(main_molecule)
|
||||
system.add_type(secondary_molecule)
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, system)
|
||||
|
||||
last_xyz_file = io.StringIO()
|
||||
last_xyz_file.writelines(
|
||||
[
|
||||
" TEST\n",
|
||||
" Configuration number : TEST = 1 1 1\n",
|
||||
" H 1.00000 1.00000 1.00000\n",
|
||||
" H 1.00000 1.00000 1.00000\n",
|
||||
]
|
||||
)
|
||||
last_xyz_file.seek(0)
|
||||
|
||||
density = dice._new_density(last_xyz_file)
|
||||
|
||||
self.assertEqual(density, 85.35451545000001)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
@mock.patch("diceplayer.interface.dice_interface.random")
|
||||
def test_make_nvt_ter(self, mock_random, mock_open):
|
||||
mock_random.random.return_value = 1
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice._make_nvt_ter(1, "test")
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
"title = Diceplayer run - NVT Thermalization\n",
|
||||
"ncores = 4\n",
|
||||
"ljname = phb.ljc\n",
|
||||
"outname = phb\n",
|
||||
"nmol = 1 50\n",
|
||||
"dens = 0.75\n",
|
||||
"temp = 300.0\n",
|
||||
"init = yes\n",
|
||||
"nstep = 2000\n",
|
||||
"vstep = 0\n",
|
||||
"mstop = 1\n",
|
||||
"accum = no\n",
|
||||
"iprint = 1\n",
|
||||
"isave = 0\n",
|
||||
"irdf = 0\n",
|
||||
"seed = 1000000\n",
|
||||
"upbuf = 360",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
@mock.patch("diceplayer.interface.dice_interface.random")
|
||||
def test_make_nvt_eq(self, mock_random, mock_open):
|
||||
mock_random.random.return_value = 1
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice._make_nvt_eq(1, "test")
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
"title = Diceplayer run - NVT Production\n",
|
||||
"ncores = 4\n",
|
||||
"ljname = phb.ljc\n",
|
||||
"outname = phb\n",
|
||||
"nmol = 1 50\n",
|
||||
"dens = 0.75\n",
|
||||
"temp = 300.0\n",
|
||||
"init = no\n",
|
||||
"nstep = 3000\n",
|
||||
"vstep = 0\n",
|
||||
"mstop = 1\n",
|
||||
"accum = no\n",
|
||||
"iprint = 1\n",
|
||||
"isave = 1000\n",
|
||||
"irdf = 40\n",
|
||||
"seed = 1000000\n",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
@mock.patch("diceplayer.interface.dice_interface.random")
|
||||
def test_make_npt_ter(self, mock_random, mock_open):
|
||||
mock_random.random.return_value = 1
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice._make_npt_ter(1, "test")
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
"title = Diceplayer run - NPT Thermalization\n",
|
||||
"ncores = 4\n",
|
||||
"ljname = phb.ljc\n",
|
||||
"outname = phb\n",
|
||||
"nmol = 1 50\n",
|
||||
"press = 1.0\n",
|
||||
"temp = 300.0\n",
|
||||
"init = no\n",
|
||||
"vstep = 600\n",
|
||||
"nstep = 5\n",
|
||||
"mstop = 1\n",
|
||||
"accum = no\n",
|
||||
"iprint = 1\n",
|
||||
"isave = 0\n",
|
||||
"irdf = 0\n",
|
||||
"seed = 1000000\n",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
@mock.patch("diceplayer.interface.dice_interface.random")
|
||||
def test_make_npt_eq(self, mock_random, mock_open):
|
||||
mock_random.random.return_value = 1
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice._make_npt_eq("test")
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
"title = Diceplayer run - NPT Production\n",
|
||||
"ncores = 4\n",
|
||||
"ljname = phb.ljc\n",
|
||||
"outname = phb\n",
|
||||
"nmol = 1 50\n",
|
||||
"press = 1.0\n",
|
||||
"temp = 300.0\n",
|
||||
"nstep = 5\n",
|
||||
"vstep = 800\n",
|
||||
"init = no\n",
|
||||
"mstop = 1\n",
|
||||
"accum = no\n",
|
||||
"iprint = 1\n",
|
||||
"isave = 1000\n",
|
||||
"irdf = 40\n",
|
||||
"seed = 1000000\n",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open)
|
||||
def test_make_potentials(self, mock_open):
|
||||
example_atom = Atom(
|
||||
lbl=1,
|
||||
na=1,
|
||||
rx=1.0,
|
||||
ry=1.0,
|
||||
rz=1.0,
|
||||
chg=1.0,
|
||||
eps=1.0,
|
||||
sig=1.0,
|
||||
)
|
||||
|
||||
main_molecule = Molecule("main_molecule")
|
||||
main_molecule.add_atom(example_atom)
|
||||
|
||||
secondary_molecule = Molecule("secondary_molecule")
|
||||
secondary_molecule.add_atom(example_atom)
|
||||
|
||||
system = System()
|
||||
system.add_type(main_molecule)
|
||||
system.add_type(secondary_molecule)
|
||||
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, system)
|
||||
|
||||
dice._make_potentials("test")
|
||||
|
||||
mock_handler = mock_open()
|
||||
calls = mock_handler.write.call_args_list
|
||||
|
||||
lines = list(map(lambda x: x[0][0], calls))
|
||||
|
||||
expected_lines = [
|
||||
"*\n",
|
||||
"2\n",
|
||||
"1 main_molecule\n",
|
||||
"1 1 1.00000 1.00000 1.00000 1.000000 1.00000 1.0000\n",
|
||||
"1 secondary_molecule\n",
|
||||
"1 1 1.00000 1.00000 1.00000 1.000000 1.00000 1.0000\n",
|
||||
]
|
||||
|
||||
self.assertEqual(lines, expected_lines)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.subprocess")
|
||||
@mock.patch(
|
||||
"builtins.open",
|
||||
new_callable=mock.mock_open,
|
||||
read_data="End of simulation\nBLABLA",
|
||||
)
|
||||
def test_run_dice_file(self, mock_open, mock_subprocess):
|
||||
mock_subprocess.call.return_value = 0
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
dice.run_dice_file(1, 1, "test")
|
||||
|
||||
self.assertTrue(mock_subprocess.call.called)
|
||||
self.assertTrue(mock_open.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.subprocess")
|
||||
@mock.patch("builtins.open", new_callable=mock.mock_open, read_data="Error\nBLABLA")
|
||||
def test_run_dice_file_raises_runtime_error_on_dice_file(
|
||||
self, mock_open, mock_subprocess
|
||||
):
|
||||
mock_subprocess.call.return_value = 0
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
with self.assertRaises(RuntimeError):
|
||||
dice.run_dice_file(1, 1, "test")
|
||||
|
||||
@mock.patch("diceplayer.interface.dice_interface.subprocess")
|
||||
@mock.patch(
|
||||
"builtins.open",
|
||||
new_callable=mock.mock_open,
|
||||
read_data="End of simulation\nBLABLA",
|
||||
)
|
||||
def test_run_dice_file_raises_runtime_error_of_dice_exit_code(
|
||||
self, mock_open, mock_subprocess
|
||||
):
|
||||
mock_subprocess.call.return_value = 1
|
||||
dice = DiceInterface()
|
||||
dice.configure(self.config, System())
|
||||
|
||||
with self.assertRaises(RuntimeError):
|
||||
dice.run_dice_file(1, 1, "test")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,115 +0,0 @@
|
||||
from diceplayer import logger
|
||||
from diceplayer.config.player_config import PlayerConfig
|
||||
from diceplayer.environment import System
|
||||
from diceplayer.interface import GaussianInterface
|
||||
from tests.mocks.mock_inputs import get_config_example
|
||||
|
||||
import yaml
|
||||
|
||||
import io
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
|
||||
class TestGaussianInterface(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
config = yaml.load(get_config_example(), Loader=yaml.Loader)
|
||||
self.config = PlayerConfig.model_validate(config["diceplayer"])
|
||||
|
||||
def test_class_instantiation(self):
|
||||
gaussian_interface = GaussianInterface()
|
||||
self.assertIsInstance(gaussian_interface, GaussianInterface)
|
||||
|
||||
def test_configure(self):
|
||||
gaussian_interface = GaussianInterface()
|
||||
|
||||
self.assertIsNone(gaussian_interface.step)
|
||||
self.assertIsNone(gaussian_interface.system)
|
||||
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
self.assertIsNotNone(gaussian_interface.step)
|
||||
self.assertIsNotNone(gaussian_interface.system)
|
||||
|
||||
def test_reset(self):
|
||||
gaussian_interface = GaussianInterface()
|
||||
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
self.assertIsNotNone(gaussian_interface.step)
|
||||
self.assertIsNotNone(gaussian_interface.system)
|
||||
|
||||
gaussian_interface.reset()
|
||||
|
||||
self.assertFalse(hasattr(gaussian_interface, "step"))
|
||||
self.assertFalse(hasattr(gaussian_interface, "system"))
|
||||
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.Path.mkdir")
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.Path.exists")
|
||||
def test_make_qm_dir(self, mock_exists, mock_mkdir):
|
||||
mock_exists.return_value = False
|
||||
|
||||
gaussian_interface = GaussianInterface()
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
gaussian_interface._make_qm_dir(1)
|
||||
|
||||
mock_exists.assert_called_once()
|
||||
mock_mkdir.assert_called_once()
|
||||
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.shutil.copy")
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.Path.exists")
|
||||
def test_copy_chk_file_from_previous_step(self, mock_exists, mock_copy):
|
||||
gaussian_interface = GaussianInterface()
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
mock_exists.side_effect = [False, True]
|
||||
|
||||
gaussian_interface._copy_chk_file_from_previous_step(2)
|
||||
|
||||
self.assertTrue(mock_exists.called)
|
||||
self.assertTrue(mock_copy.called)
|
||||
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.shutil.copy")
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.Path.exists")
|
||||
def test_copy_chk_file_from_previous_step_no_previous_step(
|
||||
self, mock_exists, mock_copy
|
||||
):
|
||||
gaussian_interface = GaussianInterface()
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
mock_exists.side_effect = [False, False]
|
||||
|
||||
with self.assertRaises(FileNotFoundError):
|
||||
gaussian_interface._copy_chk_file_from_previous_step(2)
|
||||
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.shutil.copy")
|
||||
@mock.patch("diceplayer.interface.gaussian_interface.Path.exists")
|
||||
def test_copy_chk_file_from_previous_step_current_exists(
|
||||
self, mock_exists, mock_copy
|
||||
):
|
||||
gaussian_interface = GaussianInterface()
|
||||
gaussian_interface.configure(self.config, System())
|
||||
|
||||
mock_exists.side_effect = [True, True]
|
||||
|
||||
with self.assertRaises(FileExistsError):
|
||||
gaussian_interface._copy_chk_file_from_previous_step(2)
|
||||
|
||||
# def test_start(self):
|
||||
# gaussian_interface = GaussianInterface()
|
||||
# gaussian_interface.configure(self.config, System())
|
||||
#
|
||||
# gaussian_interface._make_qm_dir = mock.Mock()
|
||||
# gaussian_interface._copy_chk_file_from_previous_step = mock.Mock()
|
||||
#
|
||||
# gaussian_interface.start(2)
|
||||
#
|
||||
# gaussian_interface._make_qm_dir.assert_called_once_with(2)
|
||||
# gaussian_interface._copy_chk_file_from_previous_step.assert_called_once_with(2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,132 +0,0 @@
|
||||
from diceplayer.utils import Logger, valid_logger
|
||||
|
||||
import io
|
||||
import logging
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
|
||||
class TestValidateLogger(unittest.TestCase):
|
||||
def test_validate_logger(self):
|
||||
class MockLogger:
|
||||
_was_set = True
|
||||
|
||||
@valid_logger
|
||||
def test_func(self):
|
||||
pass
|
||||
|
||||
MockLogger().test_func()
|
||||
|
||||
def test_validate_logger_exception(self):
|
||||
class MockLogger:
|
||||
_was_set = False
|
||||
|
||||
@valid_logger
|
||||
def test_func(self):
|
||||
pass
|
||||
|
||||
with self.assertRaises(AssertionError):
|
||||
MockLogger().test_func()
|
||||
|
||||
|
||||
class TestLogger(unittest.TestCase):
|
||||
def test_class_instantiation(self):
|
||||
logger = Logger("test")
|
||||
|
||||
self.assertIsInstance(logger, Logger)
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_set_logger_to_file(self):
|
||||
logger = Logger("test")
|
||||
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
self.assertIsNotNone(logger._logger)
|
||||
self.assertEqual(logger._logger.name, "test")
|
||||
|
||||
def test_set_logger_to_stream(self):
|
||||
logger = Logger("test")
|
||||
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
self.assertIsNotNone(logger._logger)
|
||||
self.assertEqual(logger._logger.name, "test")
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
@mock.patch("diceplayer.utils.logger.Path.exists")
|
||||
@mock.patch("diceplayer.utils.logger.Path.rename")
|
||||
def test_set_logger_if_file_exists(self, mock_rename, mock_exists):
|
||||
logger = Logger("test")
|
||||
|
||||
mock_exists.return_value = True
|
||||
logger.set_logger()
|
||||
|
||||
self.assertTrue(mock_rename.called)
|
||||
self.assertIsNotNone(logger._logger)
|
||||
self.assertEqual(logger._logger.name, "test")
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
@mock.patch("diceplayer.utils.logger.Path.exists")
|
||||
@mock.patch("diceplayer.utils.logger.Path.rename")
|
||||
def test_set_logger_if_file_not_exists(self, mock_rename, mock_exists):
|
||||
logger = Logger("test")
|
||||
|
||||
mock_exists.return_value = False
|
||||
logger.set_logger()
|
||||
|
||||
self.assertFalse(mock_rename.called)
|
||||
self.assertIsNotNone(logger._logger)
|
||||
self.assertEqual(logger._logger.name, "test")
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_close(self):
|
||||
logger = Logger("test")
|
||||
|
||||
logger.set_logger()
|
||||
logger.close()
|
||||
|
||||
self.assertEqual(len(logger._logger.handlers), 0)
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_info(self):
|
||||
logger = Logger("test")
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
with self.assertLogs(level="INFO") as cm:
|
||||
logger.info("test")
|
||||
|
||||
self.assertEqual(cm.output, ["INFO:test:test"])
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_debug(self):
|
||||
logger = Logger("test")
|
||||
logger.set_logger(stream=io.StringIO(), level=logging.DEBUG)
|
||||
|
||||
with self.assertLogs(level="DEBUG") as cm:
|
||||
logger.debug("test")
|
||||
|
||||
self.assertEqual(cm.output, ["DEBUG:test:test"])
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_warning(self):
|
||||
logger = Logger("test")
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
with self.assertLogs(level="WARNING") as cm:
|
||||
logger.warning("test")
|
||||
|
||||
self.assertEqual(cm.output, ["WARNING:test:test"])
|
||||
|
||||
@mock.patch("builtins.open", mock.mock_open())
|
||||
def test_error(self):
|
||||
logger = Logger("test")
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
with self.assertLogs(level="ERROR") as cm:
|
||||
logger.error("test")
|
||||
|
||||
self.assertEqual(cm.output, ["ERROR:test:test"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,396 +0,0 @@
|
||||
from diceplayer import logger
|
||||
from diceplayer.player import Player
|
||||
from tests.mocks.mock_inputs import mock_open
|
||||
|
||||
import io
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
|
||||
class TestPlayer(unittest.TestCase):
|
||||
def setUp(self):
|
||||
logger.set_logger(stream=io.StringIO())
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
def test_class_instantiation(self):
|
||||
# This file does not exist and it will be mocked
|
||||
player = Player("control.test.yml")
|
||||
|
||||
self.assertIsInstance(player, Player)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
def test_start(self):
|
||||
player = Player("control.test.yml")
|
||||
|
||||
player.gaussian_start = mock.MagicMock()
|
||||
player.dice_start = mock.MagicMock()
|
||||
|
||||
player.start()
|
||||
|
||||
self.assertEqual(player.dice_start.call_count, 3)
|
||||
self.assertEqual(player.gaussian_start.call_count, 3)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.Path")
|
||||
def test_create_simulation_dir_if_already_exists(self, mock_path):
|
||||
player = Player("control.test.yml")
|
||||
mock_path.return_value.exists.return_value = True
|
||||
|
||||
with self.assertRaises(FileExistsError):
|
||||
player.create_simulation_dir()
|
||||
|
||||
self.assertTrue(mock_path.called)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.Path")
|
||||
def test_create_simulation_dir_if_not_exists(self, mock_path):
|
||||
player = Player("control.test.yml")
|
||||
mock_path.return_value.exists.return_value = False
|
||||
|
||||
player.create_simulation_dir()
|
||||
|
||||
self.assertTrue(mock_path.called)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.VERSION", "test")
|
||||
@mock.patch("diceplayer.player.sys")
|
||||
@mock.patch("diceplayer.player.weekday_date_time")
|
||||
def test_print_keywords(self, mock_date_func, mock_sys):
|
||||
player = Player("control.test.yml")
|
||||
|
||||
mock_sys.version = "TEST"
|
||||
mock_date_func.return_value = "00 Test 0000 at 00:00:00"
|
||||
|
||||
with self.assertLogs() as cm:
|
||||
player.print_keywords()
|
||||
|
||||
expected_output = [
|
||||
"INFO:diceplayer:##########################################################################################\n############# Welcome to DICEPLAYER version test #############\n##########################################################################################\n",
|
||||
"INFO:diceplayer:Your python version is TEST\n",
|
||||
"INFO:diceplayer:Program started on 00 Test 0000 at 00:00:00\n",
|
||||
"INFO:diceplayer:Environment variables:",
|
||||
"INFO:diceplayer:OMP_STACKSIZE = Not set\n",
|
||||
"INFO:diceplayer:------------------------------------------------------------------------------------------\n DICE variables being used in this run:\n------------------------------------------------------------------------------------------\n",
|
||||
"INFO:diceplayer:combrule = *",
|
||||
"INFO:diceplayer:dens = 0.75",
|
||||
"INFO:diceplayer:isave = 1000",
|
||||
"INFO:diceplayer:ljname = phb.ljc",
|
||||
"INFO:diceplayer:nmol = [ 1 50 ]",
|
||||
"INFO:diceplayer:nstep = [ 2000 3000 4000 ]",
|
||||
"INFO:diceplayer:outname = phb",
|
||||
"INFO:diceplayer:press = 1.0",
|
||||
"INFO:diceplayer:progname = ~/.local/bin/dice",
|
||||
"INFO:diceplayer:randominit = first",
|
||||
"INFO:diceplayer:temp = 300.0",
|
||||
"INFO:diceplayer:upbuf = 360",
|
||||
"INFO:diceplayer:------------------------------------------------------------------------------------------\n GAUSSIAN variables being used in this run:\n------------------------------------------------------------------------------------------\n",
|
||||
"INFO:diceplayer:chg_tol = 0.01",
|
||||
"INFO:diceplayer:chgmult = [ 0 1 ]",
|
||||
"INFO:diceplayer:keywords = freq",
|
||||
"INFO:diceplayer:level = MP2/aug-cc-pVDZ",
|
||||
"INFO:diceplayer:pop = chelpg",
|
||||
"INFO:diceplayer:qmprog = g16",
|
||||
"INFO:diceplayer:\n",
|
||||
]
|
||||
|
||||
self.assertEqual(cm.output, expected_output)
|
||||
|
||||
def test_validate_atom_dict(self):
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid number of fields for site 1 for molecule type 1.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": "",
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception), "Invalid lbl fields for site 1 for molecule type 1."
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": "",
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception), "Invalid na fields for site 1 for molecule type 1."
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": "",
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid rx fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": "",
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid ry fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": "",
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid rz fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": "",
|
||||
"eps": 1.0,
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid chg fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": "",
|
||||
"sig": 1.0,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid eps fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
with self.assertRaises(ValueError) as context:
|
||||
Player.validate_atom_dict(
|
||||
molecule_type=0,
|
||||
molecule_site=0,
|
||||
atom_dict={
|
||||
"lbl": 1.0,
|
||||
"na": 1,
|
||||
"rx": 1.0,
|
||||
"ry": 1.0,
|
||||
"rz": 1.0,
|
||||
"chg": 1.0,
|
||||
"eps": 1.0,
|
||||
"sig": "",
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Invalid sig fields for site 1 for molecule type 1. Value must be a float.",
|
||||
)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.Path.exists", return_value=True)
|
||||
def test_read_potentials(self, mock_path_exists):
|
||||
player = Player("control.test.yml")
|
||||
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(player.system.molecule[0].molname, "TEST")
|
||||
self.assertEqual(len(player.system.molecule[0].atom), 1)
|
||||
|
||||
self.assertEqual(player.system.molecule[1].molname, "PLACEHOLDER")
|
||||
self.assertEqual(len(player.system.molecule[1].atom), 1)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.Path.exists")
|
||||
def test_read_potentials_error(self, mock_path_exists):
|
||||
player = Player("control.test.yml")
|
||||
|
||||
# Testing file not found error
|
||||
mock_path_exists.return_value = False
|
||||
with self.assertRaises(RuntimeError) as context:
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(str(context.exception), "Potential file phb.ljc not found.")
|
||||
|
||||
# Enabling file found for next tests
|
||||
mock_path_exists.return_value = True
|
||||
|
||||
# Testing combrule error
|
||||
with self.assertRaises(SystemExit) as context:
|
||||
player.config.dice.ljname = "phb.error.combrule.ljc"
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Error: expected a '*' or a '+' sign in 1st line of file phb.error.combrule.ljc",
|
||||
)
|
||||
|
||||
# Testing ntypes error
|
||||
with self.assertRaises(SystemExit) as context:
|
||||
player.config.dice.ljname = "phb.error.ntypes.ljc"
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Error: expected an integer in the 2nd line of file phb.error.ntypes.ljc",
|
||||
)
|
||||
|
||||
# Testing ntypes error on config
|
||||
with self.assertRaises(SystemExit) as context:
|
||||
player.config.dice.ljname = "phb.error.ntypes.config.ljc"
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Error: number of molecule types in file phb.error.ntypes.config.ljc "
|
||||
"must match that of 'nmol' keyword in config file",
|
||||
)
|
||||
|
||||
# Testing nsite error
|
||||
with self.assertRaises(ValueError) as context:
|
||||
player.config.dice.ljname = "phb.error.nsites.ljc"
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Error: expected nsites to be an integer for molecule type 1",
|
||||
)
|
||||
|
||||
# Testing molname error
|
||||
with self.assertRaises(ValueError) as context:
|
||||
player.config.dice.ljname = "phb.error.molname.ljc"
|
||||
player.read_potentials()
|
||||
|
||||
self.assertEqual(
|
||||
str(context.exception),
|
||||
"Error: expected nsites and molname for the molecule type 1",
|
||||
)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
@mock.patch("diceplayer.player.Path.exists", return_value=True)
|
||||
def test_print_potentials(self, mock_path_exists):
|
||||
player = Player("control.test.yml")
|
||||
player.read_potentials()
|
||||
|
||||
with self.assertLogs(level="INFO") as context:
|
||||
player.print_potentials()
|
||||
|
||||
expected_output = [
|
||||
"INFO:diceplayer:==========================================================================================\n Potential parameters from file phb.ljc:\n------------------------------------------------------------------------------------------\n",
|
||||
"INFO:diceplayer:Combination rule: *",
|
||||
"INFO:diceplayer:Types of molecules: 2\n",
|
||||
"INFO:diceplayer:1 atoms in molecule type 1:",
|
||||
"INFO:diceplayer:---------------------------------------------------------------------------------",
|
||||
"INFO:diceplayer:Lbl AN X Y Z Charge Epsilon Sigma Mass",
|
||||
"INFO:diceplayer:---------------------------------------------------------------------------------",
|
||||
"INFO:diceplayer:1 1 0.00000 0.00000 0.00000 0.000000 0.00000 0.0000 1.0079",
|
||||
"INFO:diceplayer:\n",
|
||||
"INFO:diceplayer:1 atoms in molecule type 2:",
|
||||
"INFO:diceplayer:---------------------------------------------------------------------------------",
|
||||
"INFO:diceplayer:Lbl AN X Y Z Charge Epsilon Sigma Mass",
|
||||
"INFO:diceplayer:---------------------------------------------------------------------------------",
|
||||
"INFO:diceplayer:1 1 0.00000 0.00000 0.00000 0.000000 0.00000 0.0000 1.0079",
|
||||
"INFO:diceplayer:\n",
|
||||
]
|
||||
|
||||
self.assertEqual(context.output, expected_output)
|
||||
|
||||
@mock.patch("builtins.open", mock_open)
|
||||
def test_dice_start(self):
|
||||
player = Player("control.test.yml")
|
||||
player.dice_interface = mock.MagicMock()
|
||||
player.dice_interface.start = mock.MagicMock()
|
||||
|
||||
player.dice_start(1)
|
||||
|
||||
player.dice_interface.start.assert_called_once()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user