def _val_iter(mapping: Mapping[KT, Any], k_type: Union[Type[KT], Tuple[Type[KT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.__iter__` method of **mapping**.""" iterator = iter(mapping) assertion.isinstance(iterator, abc.Iterator) for k in iterator: assertion.isinstance(k, k_type)
def _val_values(mapping: Mapping[Any, VT], v_type: Union[Type[VT], Tuple[Type[VT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.values` method of **mapping**.""" values = mapping.values() assertion.isinstance(values, abc.ValuesView) for v in values: assertion.isinstance(v, v_type)
def test_adf_mock(mocker: MockFixture): """Mock the ADF output.""" mol = Molecule(PATH_MOLECULES / "acetonitrile.xyz") job = adf(templates.geometry, mol) run_mocked = mocker.patch("qmflows.run") jobname = "ADFjob" dill_path = WORKDIR / jobname / "ADFjob.dill" plams_dir = WORKDIR / jobname run_mocked.return_value = ADF_Result(templates.geometry, mol, jobname, dill_path=dill_path, work_dir=plams_dir, plams_dir=plams_dir) rs = run_mocked(job) assertion.isfinite(rs.energy) assertion.isfinite(rs.h**o) assertion.isfinite(rs.lumo) # Array of runtime for each optimization assertion.isfinite(rs.runtime[-1]) # 3-dimensional vector assertion.len_eq(rs.dipole, 3) # number of steps until convergence assertion.eq(rs.optcycles, 8) # Test molecule # Molecule mol = rs.molecule assertion.isinstance(mol, Molecule) assertion.len_eq(mol, 6) # there are 6 atoms
def validate_prop_group(group: h5py.Group) -> None: """Validate the passed hdf5 **group**, ensuring it is compatible with :func:`create_prop_group` and :func:`create_prop_group`. This method is called automatically when an exception is raised by :func:`update_prop_dset`. Parameters ---------- group : :class:`h5py.Group` The to-be validated hdf5 Group. Raises ------ :exc:`AssertionError` Raised if the validation process fails. """ # noqa: E501 assertion.isinstance(group, h5py.Group) idx_ref = group.attrs['index'] idx = group.file[idx_ref] iterator = ((k, v) for k, v in group.items() if not k.endswith('_names')) for name, dset in iterator: assertion.le(len(dset), len(idx), message=f'{name!r} invalid dataset length') assertion.contains(dset.dims[0].keys(), 'index', message=f'{name!r} missing dataset scale') assertion.eq(dset.dims[0]['index'], idx, message=f'{name!r} invalid dataset scale')
def test_warns(self, tmp_path: Path) -> None: """Test that whether appropiate warning is issued.""" with pytest.warns(RuntimeWarning) as record: get_compkf("bob", tmp_path) cause: None | BaseException = getattr(record[0].message, "__cause__", None) assertion.isinstance(cause, RuntimeError)
def test_package_wrapper() -> None: """Tests for :class:`PackageWrapper<qmflows.packages.package_wrapper.PackageWrapper>`.""" s1 = Settings() s1.input.ams.Task = 'GeometryOptimization' s1.input.ams.GeometryOptimization.Convergence.Gradients = 1.0e-4 s1.input.ams.Properties.NormalModes = 'true' s1.input.DFTB.Model = 'DFTB3' s1.input.DFTB.ResourcesDir = 'DFTB.org/3ob-3-1' s2 = Settings() s2.input.basis.type = 'DZP' s2.input.basis.core = 'None' s2.input.basis.createoutput = 'None' mol = from_smiles('O') # H2O job1 = PackageWrapper(AMSJob)(s1, mol, name='amsjob') result1 = _get_result(job1, AMSJob) assertion.isinstance(result1, ResultWrapper) assertion.eq(result1.results.job.status, 'successful') job2 = PackageWrapper(ADFJob)(s2, mol, name='adfjob') result2 = _get_result(job2, ADFJob) assertion.isinstance(result2, ADF_Result) assertion.eq(result2.results.job.status, 'successful')
def _val_keys(mapping: Mapping[KT, Any], k_type: Union[Type[KT], Tuple[Type[KT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.keys` method of **mapping**.""" keys = mapping.keys() assertion.isinstance(keys, abc.KeysView) for k in keys: assertion.isinstance(k, k_type)
def _val_get(mapping: Mapping[KT, VT], key: KT, v_type: Union[Type[VT], Tuple[Type[VT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.get` method of **mapping**.""" v = mapping.get(key, default=True) # type: ignore _v = mapping.get(_Key, default=True) # type: ignore assertion.isinstance(v, v_type) assertion.is_(_v, True)
def test_dftb_opt_mock(mocker: MockFixture): """Mock a geometry optimization using DFTB.""" jobname = "dftb_geometry" job = dftb(templates.geometry, WATER, job_name=jobname) run_mocked = mock_runner(mocker, jobname) rs = run_mocked(job) # check the properties assertion.isfinite(rs.energy) assertion.len_eq(rs.dipole, 3) assertion.isinstance(rs.molecule, Molecule)
def test_empty() -> None: """Tests for :mod:`nanoutils.empty`.""" assertion.isinstance(EMPTY_SEQUENCE, abc.Sequence) assertion.isinstance(EMPTY_MAPPING, abc.Mapping) assertion.isinstance(EMPTY_COLLECTION, abc.Collection) assertion.isinstance(EMPTY_SET, abc.Set) assertion.isinstance(EMPTY_CONTAINER, abc.Container) assertion.not_(EMPTY_SEQUENCE) assertion.not_(EMPTY_MAPPING) assertion.not_(EMPTY_COLLECTION) assertion.not_(EMPTY_SET) assertion.not_(EMPTY_CONTAINER)
def test_input_validation(): """Test the input validation schema.""" schemas = ("absorption_spectrum", "derivative_couplings") paths = [ PATH_TEST / x for x in [ "input_test_absorption_spectrum.yml", "input_fast_test_derivative_couplings.yml" ] ] for s, p in zip(schemas, paths): d = process_input(p, s) assertion.isinstance(d, dict)
def test_from_pdb_array() -> None: """Test :func:`dataCAT.functions.as_pdb_array`.""" mol = molkit.readpdb(join(PATH, 'Methanol.pdb')) pdb_ar = as_pdb_array([mol], warn=False)[0] out1 = from_pdb_array(pdb_ar, warn=False) assertion.isinstance(out1, Chem.Mol) out2 = from_pdb_array(pdb_ar, rdmol=False, warn=False) for at1, at2 in zip(out2, mol): assertion.eq(at1.coords, at2.coords) assertion.eq(at1.atnum, at2.atnum)
def test_version_info() -> None: """Tests for :func:`nanoutils.VersionInfo`.""" tup1 = VersionInfo(0, 1, 2) tup2 = VersionInfo.from_str('0.1.2') assertion.eq(tup1, (0, 1, 2)) assertion.eq(tup2, (0, 1, 2)) assertion.eq(tup1.micro, tup1.patch) assertion.assert_(VersionInfo.from_str, b'0.1.2', exception=TypeError) assertion.assert_(VersionInfo.from_str, '0.1.2a', exception=ValueError) assertion.assert_(VersionInfo.from_str, '0.1.2.3.4', exception=ValueError) assertion.isinstance(version_info, VersionInfo)
def test_mol_properties(self, generate_output: Output) -> None: """Validate the properties of the output molecules.""" mol_list, *_ = generate_output ex_dict = {} for i, mol in enumerate(mol_list): smiles: None | str = mol.properties.get("smiles") anchor: None | str = mol.properties.get("anchor") name = smiles if smiles is not None else mol.get_formula() try: assertion.isinstance(smiles, str, message=f"{name} smiles") assertion.isinstance(anchor, str, message=f"{name} anchor") except AssertionError as ex: ex_dict[name] = ex eval_ex_dict(ex_dict, 1 + i)
def test_CP2K_KEYS_ALIAS() -> None: """Tests for :data:`CP2K_KEYS_ALIAS`.""" key_exclude = {'lennard_jones'} assertion.isinstance(CP2K_KEYS_ALIAS, dict) for k, v in CP2K_KEYS_ALIAS.items(): if k.endswith('14'): k = k[:-2] if k in key_exclude: continue assertion.eq(k, v[-1]) assertion.isinstance(v, tuple) assertion.eq(v[:2], ('specific', 'cp2k'))
def test_cp2k_opt(tmp_path: PathLike): """Run a simple molecular optimization.""" s = fill_cp2k_defaults(templates.geometry) # Do a single step s.specific.cp2k.motion.geo_opt.max_iter = 1 s.specific.cp2k.force_eval.dft.scf.eps_scf = 1e-1 water = Molecule(PATH_MOLECULES / "h2o.xyz", 'xyz', charge=0, multiplicity=1) job = cp2k(s, water) mol = run(job, folder=tmp_path) assertion.isinstance(mol.molecule, Molecule)
def test_orca_mock(mocker: MockFixture): """Mock a call to orca.""" methanol = Molecule(PATH_MOLECULES / "methanol.xyz") s = Settings() s.specific.orca.main = "RKS B3LYP SVP Opt NumFreq TightSCF SmallPrint" # print the orbitals s.specific.orca.scf = " print[p_mos] 1" job = orca(s, methanol) run_mocked = mocker.patch("qmflows.run") jobname = "ORCAjob" dill_path = WORKDIR / jobname / "ORCAjob.dill" plams_dir = WORKDIR / jobname run_mocked.return_value = ORCA_Result(s, methanol, jobname, dill_path=dill_path, plams_dir=plams_dir) rs = run_mocked(job) assertion.isfinite(rs.energy) assertion.isfinite(rs.runtime) assertion.isfinite(np.sum(rs.dipole)) # steps until convergence assertion.eq(rs.optcycles, 8) # Check that hessian is symmetric hess = rs.hessian assertion.isclose(np.sum(hess - hess.T), 0.0) # frequencies frequencies = rs.frequencies assertion.len_eq(frequencies, 18) # Normal modes normal_modes = rs.normal_modes assertion.shape_eq(normal_modes, (18, 18)) # Orbitals orbs = rs.orbitals assert np.isfinite(np.sum(orbs.eigenvalues)) # eigenvalues # Molecule mol = rs.molecule assertion.isinstance(mol, Molecule) assertion.len_eq(mol, 6) # there are 6 atoms
def test_assert_() -> None: """Test :meth:`AssertionManager.assert_`.""" assertion.assert_(len, [1]) assertion.assert_(len, [], invert=True) assertion.assert_(len, 1, exception=TypeError) assertion.assert_(len, [1], [1], exception=TypeError) assertion.assert_(len, [1], bob=1, exception=TypeError) try: assertion.assert_(len, [1], exception=bool) except TypeError: pass else: raise AssertionError('Failed to raise a TypeError') try: assertion.assert_(len, [1], exception=AssertionError) except ValueError: pass else: raise AssertionError('Failed to raise a ValueError') try: assertion.eq(1, 1, exception=TypeError, message='<MARKER>') except AssertionError as ex: assertion.contains(str(ex), '<MARKER>') else: raise AssertionError('Failed to raise an AssertionError') try: assertion.contains(1, 1, exception=ValueError) except AssertionError as ex: assertion.isinstance(ex.__cause__, TypeError) else: raise AssertionError('Failed to raise an AssertionError') func = operator.__invert__ assertion(False, post_process=func) assertion(True, invert=True, post_process=func) try: assertion.truth(False, message='Funcy custom message') except AssertionError as ex: assertion.contains(str(ex), 'Funcy custom message') else: raise AssertionError('Failed to raise am AssertionError')
def test_validate() -> None: """Test :meth:`PDBContainer.validate_hdf5`.""" with h5py.File(HDF5_TMP, 'a', libver='latest') as f: group = f.create_group('test') try: PDB.from_hdf5(group) except AssertionError as ex: assertion.isinstance(ex.__context__, KeyError) dset = group.create_dataset('atoms', data=[1]) else: raise AssertionError("Failed to raise an AssertionError") try: PDB.to_hdf5(group, None) except AssertionError as ex: assertion.isinstance(ex.__context__, RuntimeError) scale = group.create_dataset('index', data=[1], maxshape=(None, )) scale.make_scale('index') dset.dims[0].attach_scale(scale) else: raise AssertionError("Failed to raise an AssertionError") try: PDB.to_hdf5(group, None) except AssertionError as ex: assertion.isinstance(ex.__context__, IndexError) else: raise AssertionError("Failed to raise an AssertionError")
def _val_items(mapping: Mapping[KT, VT], k_type: Union[Type[KT], Tuple[Type[KT], ...]], v_type: Union[Type[VT], Tuple[Type[VT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.items` method of **mapping**.""" items = mapping.items() assertion.isinstance(items, abc.ItemsView) for k, v in mapping.items(): assertion.isinstance(k, k_type) assertion.isinstance(v, v_type)
def test_file_to_context() -> None: """Tests for :func:`file_to_context`.""" path_like = PATH_MOLECULES / 'mol.psf' file_like = StringIO(PSF_STR) cm1 = file_to_context(path_like) cm2 = file_to_context(file_like) assertion.isinstance(cm1, AbstractContextManager) assertion.isinstance(cm2, AbstractContextManager) assertion.isinstance(cm1.__enter__(), TextIOBase) assertion.isinstance(cm2.__enter__(), TextIOBase) sequence = range(10) assertion.assert_(file_to_context, sequence, require_iterator=False) assertion.assert_(file_to_context, sequence, require_iterator=True, exception=TypeError) assertion.assert_(file_to_context, None, exception=TypeError) assertion.assert_(file_to_context, [1, 2], exception=TypeError) assertion.assert_(file_to_context, 5.0, exception=TypeError)
def test_orca_parse_molecule(): """Test the reading of the molecule from the output.""" mol = parse_molecule(PATH_OUTPUT) assertion.isinstance(mol, plams.Molecule) assertion.len_eq(mol, 6)
def test_Distance(): """Test Distance reactivity functionality.""" d = reactivity.Distance(1, 2) s = d.get_settings(mol=mol) assertion.isinstance(s, Settings)
def test_getitem_slice(self, seq: Sequence[int], view: SequenceView[int], i: int) -> None: assertion.eq(view[:i], seq[:i]) assertion.eq(view[i:], seq[i:]) assertion.eq(view[::i], seq[::i]) assertion.isinstance(view[:], SequenceView)
def test_getitem_int(self, seq: Sequence[int], view: SequenceView[int], i: int) -> None: assertion.eq(view[i], seq[i]) assertion.isinstance(view[i], type(seq[i]))
def test_Angle(): """Test Angle reactivity functionality.""" ang = reactivity.Angle(1, 2, 3) s = ang.get_settings(mol=mol) assertion.isinstance(s, Settings)
def test_Dihedral(): """Test Angle reactivity functionality.""" dihed = reactivity.Dihedral(1, 2, 3, 4) s = dihed.get_settings(mol=mol) assertion.isinstance(s, Settings)
def _val_len(mapping: Mapping) -> None: """Validate the :meth:`~collections.abc.Mapping.__len__` method of **mapping**.""" length = len(mapping) assertion.isinstance(length, int)
def _val_getitem(mapping: Mapping[KT, VT], key: KT, v_type: Union[Type[VT], Tuple[Type[VT], ...]]) -> None: """Validate the :meth:`~collections.abc.Mapping.__getitem__` method of **mapping**.""" v = mapping[key] assertion.isinstance(v, v_type)
def _val_class(mapping: Mapping) -> None: """Validate the :class:`type` of **mapping**.""" assertion.isinstance(mapping, abc.Mapping)