From 541f131b1264e53365d28620c0d6f626a149cba1 Mon Sep 17 00:00:00 2001 From: MaksimDaniliuk Date: Wed, 1 Apr 2026 18:23:29 +0300 Subject: [PATCH] Implement update mode for integration tests (#3536) --- README.md | 16 +++ api/tests/integration/common/env_indigo.py | 10 +- api/tests/integration/common/util.py | 29 ++++ .../ref/formats/2713-star-atom.py.out | 4 +- .../integration/ref/formats/cdx_export.py.out | 70 ++++----- .../ref/formats/genbank_to_seq.py.out | 6 +- .../integration/ref/formats/ket_to_ket.py.out | 46 +++--- .../integration/ref/formats/ket_to_mol.py.out | 116 +++++++-------- .../ref/formats/ket_to_seq3letter.py.out | 2 +- .../ref/formats/ket_w_mult_group2mol.py.out | 2 +- .../ref/formats/macromol_props.py.out | 50 +++---- .../integration/ref/formats/pathway.py.out | 26 ++-- .../ref/formats/pathway_ops.py.out | 20 +-- .../ref/formats/seq3letter_to_ket.py.out | 4 +- ...eserialize_attachment_points_in_ket.py.out | 8 +- .../ref/reaction/save_ket_layout_1205.py.out | 2 +- api/tests/integration/test.py | 59 +++++--- .../tests/basic/ketfile_stereo_desc.py | 35 ++--- .../tests/formats/2713-star-atom.py | 29 +--- .../integration/tests/formats/auto_3000.py | 22 +-- .../tests/formats/axolabs_to_ket.py | 20 +-- .../integration/tests/formats/cdx_export.py | 41 ++---- .../integration/tests/formats/cdx_to_ket2.py | 31 +--- .../tests/formats/expand_monomers.py | 19 +-- .../tests/formats/fasta_to_fasta.py | 20 +-- .../integration/tests/formats/fasta_to_ket.py | 20 +-- .../tests/formats/genbank_to_seq.py | 18 +-- .../integration/tests/formats/helm_to_ket.py | 21 +-- .../integration/tests/formats/idt_to_ket.py | 20 +-- .../tests/formats/ket_ambiguous_export.py | 8 +- .../tests/formats/ket_bad_stereo.py | 8 +- .../integration/tests/formats/ket_cdxml.py | 54 +------ .../tests/formats/ket_retrosynthetic_arrow.py | 45 +----- .../tests/formats/ket_to_axolabs.py | 18 +-- .../integration/tests/formats/ket_to_cml.py | 22 +-- .../integration/tests/formats/ket_to_fasta.py | 20 +-- .../integration/tests/formats/ket_to_helm.py | 18 +-- .../integration/tests/formats/ket_to_idt.py | 18 +-- .../integration/tests/formats/ket_to_ket.py | 76 +++------- .../integration/tests/formats/ket_to_mol.py | 34 +---- .../integration/tests/formats/ket_to_rdf.py | 23 +-- .../integration/tests/formats/ket_to_rxn.py | 21 +-- .../integration/tests/formats/ket_to_sdf.py | 43 +----- .../tests/formats/ket_to_seq3letter.py | 20 +-- .../tests/formats/ket_w_mult_group2mol.py | 20 +-- .../tests/formats/ket_with_query.py | 20 +-- .../tests/formats/macromol_props.py | 20 +-- .../integration/tests/formats/mol_features.py | 19 ++- .../integration/tests/formats/mol_to_ket.py | 20 +-- .../integration/tests/formats/mol_to_seq.py | 20 +-- .../integration/tests/formats/pathway.py | 21 +-- .../integration/tests/formats/pathway_ops.py | 29 ++-- .../tests/formats/reactions_to_cdxml.py | 40 +----- .../tests/formats/reactions_to_ket.py | 22 +-- .../tests/formats/ref/ket_retro_arrow.ket | 135 ++++++++++++++++++ .../formats/retrosynthetic_arrow_to_cdx.py | 26 +--- .../formats/retrosynthetic_arrow_to_cdxml.py | 26 +--- .../integration/tests/formats/rxn_to_ket.py | 21 +-- .../integration/tests/formats/sdf_to_ket.py | 30 +--- .../tests/formats/seq3letter_to_ket.py | 20 +-- .../integration/tests/formats/seq_to_ket.py | 21 +-- ...ze_deserialize_attachment_points_in_ket.py | 30 +--- .../tests/layout/acs_style_reaction.py | 34 +---- api/tests/integration/tests/layout/basic.py | 16 +-- api/tests/integration/tests/layout/clean2d.py | 10 +- .../tests/layout/layout_orientation.py | 6 +- .../integration/tests/layout/macrocycles.py | 2 +- .../layout/reaction_layout_and_clean2d.py | 4 - .../tests/layout/selection_layout.py | 22 +-- .../tests/layout/selective_layout.py | 12 +- .../tests/layout/seq_cycles_layout.py | 37 +++-- .../integration/tests/layout/simple_cycles.py | 2 +- .../integration/tests/layout/smiles_layout.py | 22 +-- .../tests/layout/template_layout.py | 4 +- .../tests/reaction/save_ket_layout_1205.py | 24 +--- .../integration/tests/todo/macrocycles.py | 2 +- 76 files changed, 650 insertions(+), 1281 deletions(-) create mode 100644 api/tests/integration/tests/formats/ref/ket_retro_arrow.ket diff --git a/README.md b/README.md index 621932f77e..65f7df29db 100644 --- a/README.md +++ b/README.md @@ -175,6 +175,22 @@ Befor running any test you have to build and install indigo-python python api/tests/integration/test.py -t 1 -p test_name ``` + >to update all tests "ref/" using -u flag + ``` + python api/tests/integration/test.py -u + ``` + + >to update all tests "ref/" without -u flag + ``` + export INDIGO_UPDATE_TESTS="True" + python api/tests/integration/test.py + ``` + + >to update a single test's "ref/" by mask use `test_name` and -u flag + ``` + python api/tests/integration/test.py -t 1 -p test_name -u + ``` + ### To run backend API test: 1) Build and install indigo-python 2) Set environment variable by running this command: diff --git a/api/tests/integration/common/env_indigo.py b/api/tests/integration/common/env_indigo.py index d19097da2a..6f02bcab23 100644 --- a/api/tests/integration/common/env_indigo.py +++ b/api/tests/integration/common/env_indigo.py @@ -1,5 +1,6 @@ # Setup enviroment for using Indigo both for Python, Jython and IronPython import inspect +import io import os import shutil import sys @@ -209,7 +210,7 @@ def moleculeLayoutDiff( ref, delta=0.01, ref_is_file=True, - update=False, + update=os.getenv("INDIGO_UPDATE_TESTS", "False") == "True", update_format="mol", ): if ref_is_file: @@ -219,7 +220,7 @@ def moleculeLayoutDiff( txt = mol.molfile() elif update_format == "ket": txt = mol.json() - with open(ref_name, "w") as file: + with io.open(ref_name, "w", encoding="utf-8") as file: file.write(txt) m2 = indigo.loadMoleculeFromFile(ref_name) else: @@ -268,7 +269,7 @@ def reactionLayoutDiff( ref, delta=0.001, ref_is_file=True, - update=False, + update=os.getenv("INDIGO_UPDATE_TESTS", "False") == "True", update_format="mol", ): if ref_is_file: @@ -278,7 +279,7 @@ def reactionLayoutDiff( txt = rxn.rxnfile() elif update_format == "ket": txt = rxn.json() - with open(ref_name, "w") as file: + with io.open(ref_name, "w", encoding="utf-8") as file: file.write(txt) r2 = indigo.loadReactionFromFile(ref_name) else: @@ -297,6 +298,7 @@ def reactionLayoutDiff( r2.getMolecule(m.index()).molfile(), delta, ref_is_file=False, + update=False, ) error_buf.append("Molecule #{}: {}".format(m.index(), res)) return "\n ".join(error_buf) diff --git a/api/tests/integration/common/util.py b/api/tests/integration/common/util.py index a298784b33..df6037d3a7 100644 --- a/api/tests/integration/common/util.py +++ b/api/tests/integration/common/util.py @@ -1,3 +1,5 @@ +import difflib +import io import os import platform import re @@ -207,3 +209,30 @@ def check_jna_sha1(): except Exception as e: os.remove(output_path) raise e + + +def find_diff(a, b): + return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) + + +def compare_diff(ref_path, filename, data, stdout=True, diff_fn=find_diff): + path_to_file = os.path.join(ref_path, filename) + + is_update_required = os.getenv("INDIGO_UPDATE_TESTS", "False") == "True" + if is_update_required: + with io.open(path_to_file, "w", encoding="utf-8") as file: + file.write(data) + + with io.open(path_to_file, "r", encoding="utf-8") as file: + data_ref = file.read() + + diff = diff_fn(data_ref, data) + + if not stdout: + return diff + + if not diff: + print(filename + ":SUCCEED") + else: + print(filename + ":FAILED") + print(diff) diff --git a/api/tests/integration/ref/formats/2713-star-atom.py.out b/api/tests/integration/ref/formats/2713-star-atom.py.out index bbacc1c91f..1dd8acc8e7 100644 --- a/api/tests/integration/ref/formats/2713-star-atom.py.out +++ b/api/tests/integration/ref/formats/2713-star-atom.py.out @@ -1,3 +1,3 @@ *** 2713 star atom support *** -star_atom ket : SUCCEED -star_atom scxmiles : SUCCEED +star_atom.ket:SUCCEED +*C.*N.*O |$star_e;;AH_p;;star_e;$| diff --git a/api/tests/integration/ref/formats/cdx_export.py.out b/api/tests/integration/ref/formats/cdx_export.py.out index bdf5a9d311..b7a0c99c7e 100644 --- a/api/tests/integration/ref/formats/cdx_export.py.out +++ b/api/tests/integration/ref/formats/cdx_export.py.out @@ -1,41 +1,41 @@ *** Mol to CDX *** -enhanced_stereo1:success -enhanced_stereo2:success -enhanced_stereo3:success -macro/sa-mono:success -rgroup:success -stereo_either-0020:success -two_bn:success +enhanced_stereo1.b64cdx:SUCCEED +enhanced_stereo2.b64cdx:SUCCEED +enhanced_stereo3.b64cdx:SUCCEED +macro/sa-mono.b64cdx:SUCCEED +rgroup.b64cdx:SUCCEED +stereo_either-0020.b64cdx:SUCCEED +two_bn.b64cdx:SUCCEED *** KET to CDX *** -issue_1774:success -issue_1775:success +issue_1774.b64cdx:SUCCEED +issue_1775.b64cdx:SUCCEED molecule json loader: 'any' bonds are allowed only for queries *** Try as Query *** CDXML loader: Queries not supported -issue_1777:success -agents:success +issue_1777.b64cdx:SUCCEED +agents.b64cdx:SUCCEED *** CDXML to CDX *** -AlcoholOxidation_Rxn1:success -AlcoholOxidation_Rxn2:success -Amidation_Rxn1:success -Amidation_Rxn2:success -BuchwaldHartwig_Rxn1:success -BuchwaldHartwig_Rxn2:success -CarbonylReduction_Rxn1:success -CarbonylReduction_Rxn2:success -Esterification_Rxn1:success -Esterification_Rxn2:success -Grignard_Rxn1:success -Grignard_Rxn2:success -N-Alkylation_Rxn1:success -N-Alkylation_Rxn2:success -N-Sulfonylation_Rxn1:success -N-Sulfonylation_Rxn2:success -O-Alkylation_Rxn1:success -O-Alkylation_Rxn2:success -Reductive Amination_Rxn1:success -Reductive Amination_Rxn2:success -SnAr_Rxn1:success -SnAr_Rxn2:success -Suzuki_Rxn1:success -Suzuki_Rxn2:success +AlcoholOxidation_Rxn1.b64cdx:SUCCEED +AlcoholOxidation_Rxn2.b64cdx:SUCCEED +Amidation_Rxn1.b64cdx:SUCCEED +Amidation_Rxn2.b64cdx:SUCCEED +BuchwaldHartwig_Rxn1.b64cdx:SUCCEED +BuchwaldHartwig_Rxn2.b64cdx:SUCCEED +CarbonylReduction_Rxn1.b64cdx:SUCCEED +CarbonylReduction_Rxn2.b64cdx:SUCCEED +Esterification_Rxn1.b64cdx:SUCCEED +Esterification_Rxn2.b64cdx:SUCCEED +Grignard_Rxn1.b64cdx:SUCCEED +Grignard_Rxn2.b64cdx:SUCCEED +N-Alkylation_Rxn1.b64cdx:SUCCEED +N-Alkylation_Rxn2.b64cdx:SUCCEED +N-Sulfonylation_Rxn1.b64cdx:SUCCEED +N-Sulfonylation_Rxn2.b64cdx:SUCCEED +O-Alkylation_Rxn1.b64cdx:SUCCEED +O-Alkylation_Rxn2.b64cdx:SUCCEED +Reductive Amination_Rxn1.b64cdx:SUCCEED +Reductive Amination_Rxn2.b64cdx:SUCCEED +SnAr_Rxn1.b64cdx:SUCCEED +SnAr_Rxn2.b64cdx:SUCCEED +Suzuki_Rxn1.b64cdx:SUCCEED +Suzuki_Rxn2.b64cdx:SUCCEED diff --git a/api/tests/integration/ref/formats/genbank_to_seq.py.out b/api/tests/integration/ref/formats/genbank_to_seq.py.out index a3feb331a5..1a1864c7b5 100644 --- a/api/tests/integration/ref/formats/genbank_to_seq.py.out +++ b/api/tests/integration/ref/formats/genbank_to_seq.py.out @@ -1,4 +1,4 @@ *** GenBank/GenPept to Seq*** -1844-gen_bank.seq.seq:SUCCEED -1844-gen_pept.seq.seq:SUCCEED -2763-gen_spaces.seq.seq:SUCCEED +1844-gen_bank.seq:SUCCEED +1844-gen_pept.seq:SUCCEED +2763-gen_spaces.seq:SUCCEED diff --git a/api/tests/integration/ref/formats/ket_to_ket.py.out b/api/tests/integration/ref/formats/ket_to_ket.py.out index ffa2f7ff1c..f79470da84 100644 --- a/api/tests/integration/ref/formats/ket_to_ket.py.out +++ b/api/tests/integration/ref/formats/ket_to_ket.py.out @@ -1,29 +1,29 @@ *** KET to KET *** 3087-star-process.ket:SUCCEED images.ket:SUCCEED -ambiguous_monomer.ket doc loadKetDocument: SUCCEED -ambiguous_monomer.ket mol loadMolecule: SUCCEED -ambiguous_monomer.ket mol loadQueryMolecule: SUCCEED -expanded_monomer.ket doc loadKetDocument: SUCCEED -expanded_monomer.ket mol loadMolecule: SUCCEED -expanded_monomer.ket mol loadQueryMolecule: SUCCEED -helm_alias.ket doc loadKetDocument: SUCCEED -helm_alias.ket mol loadMolecule: SUCCEED -helm_alias.ket mol loadQueryMolecule: SUCCEED -helm_annotation.ket doc loadKetDocument: SUCCEED -helm_annotation.ket mol loadMolecule: SUCCEED -helm_annotation.ket mol loadQueryMolecule: SUCCEED -modification_types.ket doc loadKetDocument: SUCCEED -modification_types.ket mol loadMolecule: SUCCEED -modification_types.ket mol loadQueryMolecule: SUCCEED -monomer_shape.ket doc loadKetDocument: SUCCEED -monomer_shape.ket mol loadMolecule: SUCCEED -monomer_shape.ket mol loadQueryMolecule: SUCCEED -monomer_transform.ket doc loadKetDocument: SUCCEED -monomer_transform.ket mol loadMolecule: SUCCEED -monomer_transform.ket mol loadQueryMolecule: SUCCEED -2707_subst_count.ket ket: SUCCEED -2707_subst_count.ket mol: SUCCEED +ambiguous_monomer_doc.ket loadKetDocument:SUCCEED +ambiguous_monomer_mol.ket loadMolecule:SUCCEED +ambiguous_monomer_mol.ket loadQueryMolecule:SUCCEED +expanded_monomer_doc.ket loadKetDocument:SUCCEED +expanded_monomer_mol.ket loadMolecule:SUCCEED +expanded_monomer_mol.ket loadQueryMolecule:SUCCEED +helm_alias_doc.ket loadKetDocument:SUCCEED +helm_alias_mol.ket loadMolecule:SUCCEED +helm_alias_mol.ket loadQueryMolecule:SUCCEED +helm_annotation_doc.ket loadKetDocument:SUCCEED +helm_annotation_mol.ket loadMolecule:SUCCEED +helm_annotation_mol.ket loadQueryMolecule:SUCCEED +modification_types_doc.ket loadKetDocument:SUCCEED +modification_types_mol.ket loadMolecule:SUCCEED +modification_types_mol.ket loadQueryMolecule:SUCCEED +monomer_shape_doc.ket loadKetDocument:SUCCEED +monomer_shape_mol.ket loadMolecule:SUCCEED +monomer_shape_mol.ket loadQueryMolecule:SUCCEED +monomer_transform_doc.ket loadKetDocument:SUCCEED +monomer_transform_mol.ket loadMolecule:SUCCEED +monomer_transform_mol.ket loadQueryMolecule:SUCCEED +2707_subst_count.ket:SUCCEED +2707_subst_count.mol:SUCCEED 3069-reaction.ket:SUCCEED multi_merge4.ket:SUCCEED mixed_reaction.ket:SUCCEED diff --git a/api/tests/integration/ref/formats/ket_to_mol.py.out b/api/tests/integration/ref/formats/ket_to_mol.py.out index 515f69eeae..440789a920 100644 --- a/api/tests/integration/ref/formats/ket_to_mol.py.out +++ b/api/tests/integration/ref/formats/ket_to_mol.py.out @@ -1,59 +1,59 @@ *** KET to MOL *** -3068-star-issue.ket:SUCCEED -3178-any-bond.ket:SUCCEED -3227-copolymer.ket:SUCCEED -3343-dir-expanded.ket:SUCCEED -5amd.ket:SUCCEED -accl_no_class.ket:SUCCEED -acgt_1412.ket:SUCCEED -anacyclamide.ket:SUCCEED -chem.ket:SUCCEED -chem_rna_hydro.ket:SUCCEED -conj_no_class.ket:SUCCEED -conjugate.ket:SUCCEED -cysteine.ket:SUCCEED -dala.ket:SUCCEED -dcysteine.ket:SUCCEED -dna_mod.ket:SUCCEED -dthymine.ket:SUCCEED -exp-valence-0.ket:SUCCEED -flip_rotate.ket:SUCCEED -flip_rotate_2000.ket:SUCCEED -flip_rotate_rna.ket:SUCCEED -fmoc.ket:SUCCEED -hydro_atp_ch.ket:SUCCEED -issue_1476.ket:SUCCEED -issue_2699_rlogic.ket:SUCCEED -issue_2702.ket:SUCCEED -macro/R2R3R4.ket:SUCCEED -macro/conjugates/pep-chem-rna.ket:SUCCEED -macro/conjugates/peptide_rna.ket:SUCCEED -macro/dendromers/dendro-peptide.ket:SUCCEED -macro/disulfide/disulfide_peptide_cycle.ket:SUCCEED -macro/hundred-monomers.ket:SUCCEED -macro/left_phosphate/left_phosphate.ket:SUCCEED -macro/linear/linear_dna.ket:SUCCEED -macro/linear/linear_multi.ket:SUCCEED -macro/linear/linear_peptide.ket:SUCCEED -macro/linear/linear_rna.ket:SUCCEED -macro/modified/mod_dna.ket:SUCCEED -macro/modified/mod_peptide.ket:SUCCEED -macro/modified/mod_rna.ket:SUCCEED -macro/modified/mod_rna_peptide.ket:SUCCEED -macro/peptide-rna/peptide-rna.ket:SUCCEED -macro/peptide-rna/peptide-rna-ac.ket:SUCCEED -macro/polyphosphate/polyphosphate_rna.ket:SUCCEED -macro/sa-mono.ket:SUCCEED -macro/terminators/terms_peptide.ket:SUCCEED -mon_long_id.ket:SUCCEED -pepchem.ket:SUCCEED -peptides.ket:SUCCEED -query_explicit_val.ket:SUCCEED -rna_mod.ket:SUCCEED -sgroup_class.ket:SUCCEED -sgroups_mul.ket:SUCCEED -suplabel.ket:SUCCEED -taspoglutide.ket:SUCCEED -thymine.ket:SUCCEED -empty_apid.ket:SUCCEED -ket-reaction-arrow.ket:SUCCEED +3068-star-issue.mol:SUCCEED +3178-any-bond.mol:SUCCEED +3227-copolymer.mol:SUCCEED +3343-dir-expanded.mol:SUCCEED +5amd.mol:SUCCEED +accl_no_class.mol:SUCCEED +acgt_1412.mol:SUCCEED +anacyclamide.mol:SUCCEED +chem.mol:SUCCEED +chem_rna_hydro.mol:SUCCEED +conj_no_class.mol:SUCCEED +conjugate.mol:SUCCEED +cysteine.mol:SUCCEED +dala.mol:SUCCEED +dcysteine.mol:SUCCEED +dna_mod.mol:SUCCEED +dthymine.mol:SUCCEED +exp-valence-0.mol:SUCCEED +flip_rotate.mol:SUCCEED +flip_rotate_2000.mol:SUCCEED +flip_rotate_rna.mol:SUCCEED +fmoc.mol:SUCCEED +hydro_atp_ch.mol:SUCCEED +issue_1476.mol:SUCCEED +issue_2699_rlogic.mol:SUCCEED +issue_2702.mol:SUCCEED +macro/R2R3R4.mol:SUCCEED +macro/conjugates/pep-chem-rna.mol:SUCCEED +macro/conjugates/peptide_rna.mol:SUCCEED +macro/dendromers/dendro-peptide.mol:SUCCEED +macro/disulfide/disulfide_peptide_cycle.mol:SUCCEED +macro/hundred-monomers.mol:SUCCEED +macro/left_phosphate/left_phosphate.mol:SUCCEED +macro/linear/linear_dna.mol:SUCCEED +macro/linear/linear_multi.mol:SUCCEED +macro/linear/linear_peptide.mol:SUCCEED +macro/linear/linear_rna.mol:SUCCEED +macro/modified/mod_dna.mol:SUCCEED +macro/modified/mod_peptide.mol:SUCCEED +macro/modified/mod_rna.mol:SUCCEED +macro/modified/mod_rna_peptide.mol:SUCCEED +macro/peptide-rna/peptide-rna.mol:SUCCEED +macro/peptide-rna/peptide-rna-ac.mol:SUCCEED +macro/polyphosphate/polyphosphate_rna.mol:SUCCEED +macro/sa-mono.mol:SUCCEED +macro/terminators/terms_peptide.mol:SUCCEED +mon_long_id.mol:SUCCEED +pepchem.mol:SUCCEED +peptides.mol:SUCCEED +query_explicit_val.mol:SUCCEED +rna_mod.mol:SUCCEED +sgroup_class.mol:SUCCEED +sgroups_mul.mol:SUCCEED +suplabel.mol:SUCCEED +taspoglutide.mol:SUCCEED +thymine.mol:SUCCEED +empty_apid.mol:SUCCEED +ket-reaction-arrow.mol:SUCCEED diff --git a/api/tests/integration/ref/formats/ket_to_seq3letter.py.out b/api/tests/integration/ref/formats/ket_to_seq3letter.py.out index d0565baff1..8fdbb51ddc 100644 --- a/api/tests/integration/ref/formats/ket_to_seq3letter.py.out +++ b/api/tests/integration/ref/formats/ket_to_seq3letter.py.out @@ -1,4 +1,4 @@ *** KET to 3 LETTER SEQUENCE *** -peptides_3letter : SUCCEED +peptides_3letter.seq3:SUCCEED Test 'issue_3200': got expected error 'Only amino acids can be saved as three letter amino acid codes' Test 'peptides_molecule': got expected error 'Sequence saver: Can't save micro-molecules to sequence format' diff --git a/api/tests/integration/ref/formats/ket_w_mult_group2mol.py.out b/api/tests/integration/ref/formats/ket_w_mult_group2mol.py.out index 9965c1748f..96bf5d89c6 100644 --- a/api/tests/integration/ref/formats/ket_w_mult_group2mol.py.out +++ b/api/tests/integration/ref/formats/ket_w_mult_group2mol.py.out @@ -1,2 +1,2 @@ *** KET to MOL *** -ket_with_mult_group.ket:SUCCEED +ket_with_mult_group.mol:SUCCEED diff --git a/api/tests/integration/ref/formats/macromol_props.py.out b/api/tests/integration/ref/formats/macromol_props.py.out index 2630a52837..c502069221 100644 --- a/api/tests/integration/ref/formats/macromol_props.py.out +++ b/api/tests/integration/ref/formats/macromol_props.py.out @@ -1,29 +1,29 @@ *** HELM to KET *** -2928-props-r3.json: SUCCEED -props_amino_full_mol_selected.json: SUCCEED -props_amino_mol_selected.json: SUCCEED -props_amino_one_selected.json: SUCCEED -props_amino_selected_mol.json: SUCCEED -props_amino_selected_mol_part.json: SUCCEED -props_bases_no_sugar.json: SUCCEED -props_connected_via_chem.json: SUCCEED -props_connected_via_micro.json: SUCCEED -props_dna_base_selected.json: SUCCEED -props_dna_nucleotide_selected.json: SUCCEED -props_dna_phosphate_selected.json: SUCCEED -props_double_dna.json: SUCCEED -props_double_dna_gc.json: SUCCEED -props_double_dna_p.json: SUCCEED -props_double_dna_single.json: SUCCEED -props_double_dna_unsplit.json: SUCCEED -props_issue_3053.json: SUCCEED -props_issue_3177.json: SUCCEED -props_mol_connected_to_mol.json: SUCCEED -props_nucleoside_peptide.json: SUCCEED -props_only_micro.json: SUCCEED -props_peptides.json: SUCCEED -props_peptides_micro.json: SUCCEED -props_rna_with_mol.json: SUCCEED +2928-props-r3.json:SUCCEED +props_amino_full_mol_selected.json:SUCCEED +props_amino_mol_selected.json:SUCCEED +props_amino_one_selected.json:SUCCEED +props_amino_selected_mol.json:SUCCEED +props_amino_selected_mol_part.json:SUCCEED +props_bases_no_sugar.json:SUCCEED +props_connected_via_chem.json:SUCCEED +props_connected_via_micro.json:SUCCEED +props_dna_base_selected.json:SUCCEED +props_dna_nucleotide_selected.json:SUCCEED +props_dna_phosphate_selected.json:SUCCEED +props_double_dna.json:SUCCEED +props_double_dna_gc.json:SUCCEED +props_double_dna_p.json:SUCCEED +props_double_dna_single.json:SUCCEED +props_double_dna_unsplit.json:SUCCEED +props_issue_3053.json:SUCCEED +props_issue_3177.json:SUCCEED +props_mol_connected_to_mol.json:SUCCEED +props_nucleoside_peptide.json:SUCCEED +props_only_micro.json:SUCCEED +props_peptides.json:SUCCEED +props_peptides_micro.json:SUCCEED +props_rna_with_mol.json:SUCCEED UPC=0: SUCCEED UPC=1e+41: SUCCEED NAC=0: SUCCEED diff --git a/api/tests/integration/ref/formats/pathway.py.out b/api/tests/integration/ref/formats/pathway.py.out index 5e81d30289..dd722ced24 100644 --- a/api/tests/integration/ref/formats/pathway.py.out +++ b/api/tests/integration/ref/formats/pathway.py.out @@ -1,13 +1,13 @@ -pathway1.rdf:SUCCEED -pathway2.rdf:SUCCEED -pathway3.rdf:SUCCEED -pathway4.rdf:SUCCEED -pathway5.rdf:SUCCEED -pathway6.rdf:SUCCEED -pathway7.rdf:SUCCEED -pathway8.rdf:SUCCEED -pathway9.rdf:SUCCEED -pathway10.rdf:SUCCEED -pathway11.rdf:SUCCEED -pathway12.rdf:SUCCEED -pathway_mon.rdf:SUCCEED +pathway1.ket:SUCCEED +pathway2.ket:SUCCEED +pathway3.ket:SUCCEED +pathway4.ket:SUCCEED +pathway5.ket:SUCCEED +pathway6.ket:SUCCEED +pathway7.ket:SUCCEED +pathway8.ket:SUCCEED +pathway9.ket:SUCCEED +pathway10.ket:SUCCEED +pathway11.ket:SUCCEED +pathway12.ket:SUCCEED +pathway_mon.ket:SUCCEED diff --git a/api/tests/integration/ref/formats/pathway_ops.py.out b/api/tests/integration/ref/formats/pathway_ops.py.out index b72229598a..f8b8e2bb51 100644 --- a/api/tests/integration/ref/formats/pathway_ops.py.out +++ b/api/tests/integration/ref/formats/pathway_ops.py.out @@ -1,11 +1,11 @@ *** PATHWAY AROMATIZE/DEAROMATIZE *** -pathway1.rdf:SUCCEED -pathway2.rdf:SUCCEED -pathway3.rdf:SUCCEED -pathway4.rdf:SUCCEED -pathway5.rdf:SUCCEED -pathway6.rdf:SUCCEED -pathway7.rdf:SUCCEED -pathway8.rdf:SUCCEED -pathway9.rdf:SUCCEED -pathway10.rdf:SUCCEED +pathway1.ket:SUCCEED +pathway2.ket:SUCCEED +pathway3.ket:SUCCEED +pathway4.ket:SUCCEED +pathway5.ket:SUCCEED +pathway6.ket:SUCCEED +pathway7.ket:SUCCEED +pathway8.ket:SUCCEED +pathway9.ket:SUCCEED +pathway10.ket:SUCCEED diff --git a/api/tests/integration/ref/formats/seq3letter_to_ket.py.out b/api/tests/integration/ref/formats/seq3letter_to_ket.py.out index c02a96422f..889b2c88c8 100644 --- a/api/tests/integration/ref/formats/seq3letter_to_ket.py.out +++ b/api/tests/integration/ref/formats/seq3letter_to_ket.py.out @@ -1,6 +1,6 @@ *** 3 LETTER SEQUENCE to KET *** -peptides_3letter : SUCCEED -peptides_3letter_line_break : SUCCEED +peptides_3letter.ket:SUCCEED +peptides_3letter_line_break.ket:SUCCEED Test 'ALA': got expected error 'Given string cannot be interpreted as a valid three letter sequence because of incorrect formatting.' Test 'Al a': got expected error 'Given string cannot be interpreted as a valid three letter sequence because of incorrect formatting.' Test 'ala': got expected error 'Given string cannot be interpreted as a valid three letter sequence because of incorrect formatting.' diff --git a/api/tests/integration/ref/formats/serialize_deserialize_attachment_points_in_ket.py.out b/api/tests/integration/ref/formats/serialize_deserialize_attachment_points_in_ket.py.out index 33ebff786b..7a63bc3c17 100644 --- a/api/tests/integration/ref/formats/serialize_deserialize_attachment_points_in_ket.py.out +++ b/api/tests/integration/ref/formats/serialize_deserialize_attachment_points_in_ket.py.out @@ -1,7 +1,7 @@ *** KET to KET *** -super_atom_attachment_point_w_leav_pnt.ket:SUCCEED +super_atom_attachment_point_w_leav_pnt_out.ket:SUCCEED molecule json loader: Attachment atom in a superatom is mandatory. Check input ket-file -super_atom_attachment_point_wo_leav_pnt.ket:SUCCEED +super_atom_attachment_point_wo_leav_pnt_out.ket:SUCCEED *** MOL to MOL *** -super_atom_attachment_point_w_leav_pnt.mol:SUCCEED -super_atom_attachment_point_wo_leav_pnt.mol:SUCCEED +super_atom_attachment_point_w_leav_pnt_out.mol:SUCCEED +super_atom_attachment_point_wo_leav_pnt_out.mol:SUCCEED diff --git a/api/tests/integration/ref/reaction/save_ket_layout_1205.py.out b/api/tests/integration/ref/reaction/save_ket_layout_1205.py.out index b15a278249..6c0f545a2d 100644 --- a/api/tests/integration/ref/reaction/save_ket_layout_1205.py.out +++ b/api/tests/integration/ref/reaction/save_ket_layout_1205.py.out @@ -1 +1 @@ -Test passed \ No newline at end of file +issue_1205.ket:SUCCEED diff --git a/api/tests/integration/test.py b/api/tests/integration/test.py index ae3d7c751d..4287a8533d 100755 --- a/api/tests/integration/test.py +++ b/api/tests/integration/test.py @@ -137,6 +137,8 @@ def main(): python_exec = sys.argv[i + 1] elif sys.argv[i] == "-platform": overridePlatform(sys.argv[i + 1]) + elif sys.argv[i] == "-u": + os.environ["INDIGO_UPDATE_TESTS"] = "True" else: print("Unexpected options: %s" % (sys.argv[i])) exit() @@ -267,9 +269,22 @@ def run_analyze_test(args): module_filename = os.path.join(tests_dir, root, filename) tspent = run_test_module(module_filename) + stdout_thread = stdout_thread_printer.read_and_clean() + base_dir = os.path.join(output_dir_base, root) + + # Update ref files + is_ref_update_required = ( + os.getenv("INDIGO_UPDATE_TESTS", "False") == "True" + ) + if is_ref_update_required: + ref_file_to_update = determine_path_based_on_platform( + base_dir, filename + ) + with open(ref_file_to_update, "wb") as f: + f.write(stdout_thread) with open(out_filename, "wb") as f: - f.write(stdout_thread_printer.read_and_clean()) + f.write(stdout_thread) with open(err_filename, "wb") as f: f.write(stderr_thredd_printer.read_and_clean()) @@ -279,34 +294,14 @@ def run_analyze_test(args): os.remove(err_filename) else: failed_stderr = True - base_dir = os.path.join(output_dir_base, root) base_output_file = os.path.join(base_dir, filename + ".out") base_exists = False ndiffcnt = 0 diff_file = None if file_exists(base_output_file): diff_file = os.path.join(test_dir, filename + ".diff") - # copy reference file - if isJython() and file_exists( - os.path.join(base_dir, "jython", filename + ".out") - ): - base_output_file = os.path.join( - base_dir, "jython", filename + ".out" - ) - elif isIronPython() and file_exists( - os.path.join(base_dir, "iron", filename + ".out") - ): - base_output_file = os.path.join( - base_dir, "iron", filename + ".out" - ) - else: - sn = getPlatform() - if sn and file_exists( - os.path.join(base_dir, sn, filename + ".out") - ): - base_output_file = os.path.join( - base_dir, sn, filename + ".out" - ) + # determine platform and copy reference file + base_output_file = determine_path_based_on_platform(base_dir, filename) new_ref_file = os.path.join(test_dir, filename + ".std") if not os.path.normpath( os.path.abspath(base_output_file) @@ -373,6 +368,24 @@ def run_test_module(module_filename): return tspent +def determine_path_based_on_platform(base_dir_path, file_name): + if isJython() and file_exists( + os.path.join(base_dir_path, "jython", file_name + ".out") + ): + return os.path.join(base_dir_path, "jython", file_name + ".out") + elif isIronPython() and file_exists( + os.path.join(base_dir_path, "iron", file_name + ".out") + ): + return os.path.join(base_dir_path, "iron", file_name + ".out") + else: + sn = getPlatform() + if sn and file_exists( + os.path.join(base_dir_path, sn, file_name + ".out") + ): + return os.path.join(base_dir_path, sn, file_name + ".out") + return os.path.join(base_dir_path, file_name + ".out") + + if __name__ == "__main__": result = main() if result: diff --git a/api/tests/integration/tests/basic/ketfile_stereo_desc.py b/api/tests/integration/tests/basic/ketfile_stereo_desc.py index 039769b3e5..6609bd9575 100644 --- a/api/tests/integration/tests/basic/ketfile_stereo_desc.py +++ b/api/tests/integration/tests/basic/ketfile_stereo_desc.py @@ -1,18 +1,13 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff, find_diff from env_indigo import * threading.stack_size(2 * 1024 * 1024) @@ -27,18 +22,13 @@ def stereo_desc_test(py_file, out_queue): indigo.setOption("json-saving-pretty", True) for filename in sorted(os.listdir(root)): - ketfile = joinPathPy( - os.path.join(ref_path, filename[:-4] + ".ket"), __file__ - ) mol = indigo.loadMoleculeFromFile(os.path.join(root, filename)) mol_json_no_cip = mol.json() indigo.setOption("json-saving-add-stereo-desc", True) mol_json_cip = mol.json() - # with open(ketfile, "w") as file: - # file.write(mol_json_cip) - with open(ketfile, "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, mol_json_cip) + diff = compare_diff( + ref_path, filename[:-4] + ".ket", mol_json_cip, stdout=False + ) if not diff: diff = find_diff(mol_json_no_cip, mol_json_cip) indigo.setOption("json-saving-add-stereo-desc", False) @@ -76,17 +66,12 @@ def stereo_desc_test(py_file, out_queue): ) indigo.setOption("json-use-native-precision", True) - ketfile = joinPathPy(os.path.join(ref_path, "crazystereo.ket"), __file__) - # with open(ketfile, "w") as file: - # file.write(rxn.json()) - with open(ketfile, "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, rxn.json()) - if not diff: - str_res += filename + ":SUCCEED\n" - else: - str_res += filename + ":FAILED\n" - str_res += diff + "\n" + diff = compare_diff(ref_path, "crazystereo.ket", rxn.json(), stdout=False) + if not diff: + str_res += filename + ":SUCCEED\n" + else: + str_res += filename + ":FAILED\n" + str_res += diff + "\n" out_queue.put(str_res) diff --git a/api/tests/integration/tests/formats/2713-star-atom.py b/api/tests/integration/tests/formats/2713-star-atom.py index 741c7e078e..26da5c2806 100644 --- a/api/tests/integration/tests/formats/2713-star-atom.py +++ b/api/tests/integration/tests/formats/2713-star-atom.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -28,23 +23,9 @@ def find_diff(a, b): expected_smiles = "*C.*N.*O |$;;AH_p;;star_e;$|" mol = indigo.loadMolecule(expected_smiles) - -# with open(os.path.join(ref_path, filename) + ".ket", "w") as file: -# file.write(mol.json()) -with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() -diff = find_diff(ket_ref, ket) -if not diff: - print(filename + " ket : SUCCEED") -else: - print(filename + " ket : FAILED") - print(diff) +compare_diff(ref_path, filename + ".ket", ket) + indigo.setOption("smiles-saving-format", "chemaxon") smiles3 = mol.smiles() -diff = find_diff(smiles3, smiles3) -if not diff: - print(filename + " scxmiles : SUCCEED") -else: - print(filename + " scxmiles : FAILED") - print(diff) +print(smiles3) diff --git a/api/tests/integration/tests/formats/auto_3000.py b/api/tests/integration/tests/formats/auto_3000.py index 4216be421b..b3ba13a6db 100644 --- a/api/tests/integration/tests/formats/auto_3000.py +++ b/api/tests/integration/tests/formats/auto_3000.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -27,16 +22,5 @@ def find_diff(a, b): files.sort() for filename in files: mol = indigo.loadMoleculeFromFile(os.path.join(root, filename + ".mol")) - - # with open(os.path.join(ref_path, filename) + ".mol", "w") as file: - # file.write(mol.molfile()) - with open(os.path.join(ref_path, filename) + ".mol", "r") as file: - mol_ref = file.read() - mol_txt = mol.molfile() - diff = find_diff(mol_ref, mol_txt) - if not diff: - print(filename + ".mol:SUCCEED") - else: - print(filename + ".mol:FAILED") - print(diff) + compare_diff(ref_path, filename + ".mol", mol_txt) diff --git a/api/tests/integration/tests/formats/axolabs_to_ket.py b/api/tests/integration/tests/formats/axolabs_to_ket.py index 3a81cb99ed..8f2ebc1b19 100644 --- a/api/tests/integration/tests/formats/axolabs_to_ket.py +++ b/api/tests/integration/tests/formats/axolabs_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -49,16 +44,7 @@ def find_diff(a, b): for filename in sorted(axolabs_data.keys()): mol = indigo.loadAxoLabs(axolabs_data[filename], lib) ket = mol.json() - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) axolabs_errors = { "5'-pACsGsUsp-3'": "Invalid AxoLabs sequence: phosphate 's' can only be internal", diff --git a/api/tests/integration/tests/formats/cdx_export.py b/api/tests/integration/tests/formats/cdx_export.py index 2c46af2c07..c8efc5c9d6 100644 --- a/api/tests/integration/tests/formats/cdx_export.py +++ b/api/tests/integration/tests/formats/cdx_export.py @@ -1,18 +1,13 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -40,20 +35,18 @@ def find_diff(a, b): def test_file(filename, suffix=".mol"): + ref_filename = filename + ".b64cdx" try: mol = indigo.loadMoleculeFromFile( os.path.join(root, filename + suffix) ) resb64 = mol.b64cdx() - # with open(os.path.join(ref_path, filename + ".b64cdx"), 'w') as file: - # data = file.write(resb64) - with open(os.path.join(ref_path, filename + ".b64cdx"), "r") as file: - refb64 = file.read() try: indigo.loadMolecule(resb64) except IndigoException as e: print(getIndigoExceptionText(e)) - print(filename + (":success" if refb64 == resb64 else ":failed")) + compare_diff(ref_path, ref_filename, resb64) + except IndigoException as e: print(getIndigoExceptionText(e)) print("*** Try as Query ***") @@ -61,15 +54,11 @@ def test_file(filename, suffix=".mol"): os.path.join(root, filename + suffix) ) resb64 = mol.b64cdx() - # with open(os.path.join(ref_path, filename + ".b64cdx"), 'w') as file: - # data = file.write(resb64) - with open(os.path.join(ref_path, filename + ".b64cdx"), "r") as file: - refb64 = file.read() try: indigo.loadQueryMolecule(resb64) except IndigoException as e: print(getIndigoExceptionText(e)) - print(filename + (":success" if refb64 == resb64 else ":failed")) + compare_diff(ref_path, ref_filename, resb64) for filename in files: @@ -86,22 +75,18 @@ def test_file(filename, suffix=".mol"): files.sort() for filename in files: + ref_filename = filename + ".b64cdx" try: rea = indigo.loadReactionFromFile( os.path.join(root, filename + ".ket") ) resb64 = rea.b64cdx() - # with open(os.path.join(ref_path, filename + ".b64cdx"), 'w') as file: - # data = file.write(resb64) - with open(os.path.join(ref_path, filename + ".b64cdx"), "r") as file: - refb64 = file.read() - try: indigo.loadReaction(resb64) except IndigoException as e: print(getIndigoExceptionText(e)) + compare_diff(ref_path, ref_filename, resb64) - print(filename + (":success" if refb64 == resb64 else ":failed")) except IndigoException as e: print(getIndigoExceptionText(e)) print("*** Try as Reaction Query ***") @@ -109,15 +94,11 @@ def test_file(filename, suffix=".mol"): os.path.join(root, filename + ".ket") ) resb64 = rea.b64cdx() - # with open(os.path.join(ref_path, filename + ".b64cdx"), 'w') as file: - # data = file.write(resb64) - with open(os.path.join(ref_path, filename + ".b64cdx"), "r") as file: - refb64 = file.read() try: indigo.loadQueryReaction(resb64) except IndigoException as e: print(getIndigoExceptionText(e)) - print(filename + (":success" if refb64 == resb64 else ":failed")) + compare_diff(ref_path, ref_filename, resb64) print("*** CDXML to CDX ***") @@ -157,11 +138,7 @@ def test_file(filename, suffix=".mol"): os.path.join(root_cdxml, filename + ".cdxml") ) resb64 = rea.b64cdx() - # with open(os.path.join(ref_path, filename + ".b64cdx"), "w") as file: - # file.write(resb64) - with open(os.path.join(ref_path, filename + ".b64cdx"), "r") as file: - refb64 = file.read() - print(filename + (":success" if refb64 == resb64 else ":failed")) + compare_diff(ref_path, filename + ".b64cdx", resb64) except IndigoException as e: print(getIndigoExceptionText(e)) diff --git a/api/tests/integration/tests/formats/cdx_to_ket2.py b/api/tests/integration/tests/formats/cdx_to_ket2.py index 07f3e3c06f..d45dd526cc 100644 --- a/api/tests/integration/tests/formats/cdx_to_ket2.py +++ b/api/tests/integration/tests/formats/cdx_to_ket2.py @@ -1,18 +1,12 @@ -import difflib -import io import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -45,24 +39,5 @@ def find_diff(a, b): os.path.join(root, filename) ) ket = qmol.json() - - # with open( - # os.path.join(ref_path, os.path.splitext(filename)[0]) + ".ket", - # "w", - # encoding="utf-8", - # ) as file: - # file.write(ket) - - with io.open( - os.path.join(ref_path, os.path.splitext(filename)[0]) + ".ket", - "r", - encoding="utf-8", - ) as file: - ket_ref = file.read() - - diff = find_diff(ket_ref, ket) - if not diff: - print(os.path.splitext(filename)[0] + ".ket:SUCCEED") - else: - print(os.path.splitext(filename)[0] + ".ket:FAILED") - print(diff) + ref_filename = os.path.splitext(filename)[0] + ".ket" + compare_diff(ref_path, ref_filename, ket) diff --git a/api/tests/integration/tests/formats/expand_monomers.py b/api/tests/integration/tests/formats/expand_monomers.py index 0c486a58a1..b26f1b8889 100644 --- a/api/tests/integration/tests/formats/expand_monomers.py +++ b/api/tests/integration/tests/formats/expand_monomers.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -48,15 +43,5 @@ def find_diff(a, b): except Exception as e: print("Test %s failed: %s" % (filename, e)) continue - - # with open(os.path.join(ref, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref, filename + ".ket", ket) diff --git a/api/tests/integration/tests/formats/fasta_to_fasta.py b/api/tests/integration/tests/formats/fasta_to_fasta.py index 026bffa4d0..4e4b946638 100644 --- a/api/tests/integration/tests/formats/fasta_to_fasta.py +++ b/api/tests/integration/tests/formats/fasta_to_fasta.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -43,19 +38,10 @@ def find_diff(a, b): except Exception as e: print("%s.fasta:FAILED - %s" % (filename, e)) continue - # with open(os.path.join(ref_path, filename) + ".fasta", "w") as file: - # file.write(mol.fasta()) - with open(os.path.join(ref_path, filename) + ".fasta", "r") as file: - fasta_ref = file.read() try: fasta = mol.fasta(lib) except Exception as e: print(filename + ".fasta:FAILED") print(e) continue - diff = find_diff(fasta_ref, fasta) - if not diff: - print(filename + ".fasta:SUCCEED") - else: - print(filename + ".fasta:FAILED") - print(diff) + compare_diff(ref_path, filename + ".fasta", fasta) diff --git a/api/tests/integration/tests/formats/fasta_to_ket.py b/api/tests/integration/tests/formats/fasta_to_ket.py index 3599701565..800fc53fbe 100644 --- a/api/tests/integration/tests/formats/fasta_to_ket.py +++ b/api/tests/integration/tests/formats/fasta_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -54,17 +49,8 @@ def remove_prefix(s, prefix="com.epam.indigo.IndigoException: "): mol = indigo.loadFastaFromFile( os.path.join(root, filename + ".fasta"), desc["seq_type"], lib ) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) except: print( filename + ".fasta" + ":" + remove_prefix(str(sys.exc_info()[1])) diff --git a/api/tests/integration/tests/formats/genbank_to_seq.py b/api/tests/integration/tests/formats/genbank_to_seq.py index ff927cb0f6..1a67b64131 100644 --- a/api/tests/integration/tests/formats/genbank_to_seq.py +++ b/api/tests/integration/tests/formats/genbank_to_seq.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -37,14 +32,5 @@ def find_diff(a, b): mol = indigo.loadSequenceFromFile( os.path.join(root, filename), infile["seq_type"], lib ) - # with open(os.path.join(ref_path, filename), "w") as file: - # file.write(mol.sequence(lib)) - with open(os.path.join(ref_path, filename), "r") as file: - seq_ref = file.read() seq = mol.sequence(lib) - diff = find_diff(seq_ref, seq) - if not diff: - print(filename + ".seq:SUCCEED") - else: - print(filename + ".seq:FAILED") - print(diff) + compare_diff(ref_path, filename, seq) diff --git a/api/tests/integration/tests/formats/helm_to_ket.py b/api/tests/integration/tests/formats/helm_to_ket.py index 6adbb670c0..5f10954fa0 100644 --- a/api/tests/integration/tests/formats/helm_to_ket.py +++ b/api/tests/integration/tests/formats/helm_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -68,18 +63,8 @@ def find_diff(a, b): for filename in sorted(helm_data.keys()): try: mol = indigo.loadHelm(helm_data[filename], lib) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) - print(ket) + compare_diff(ref_path, filename + ".ket", ket) except IndigoException as e: text = getIndigoExceptionText(e) print(filename + ".ket:FAILED - " + text) diff --git a/api/tests/integration/tests/formats/idt_to_ket.py b/api/tests/integration/tests/formats/idt_to_ket.py index 059b17a9c1..a84bf64075 100644 --- a/api/tests/integration/tests/formats/idt_to_ket.py +++ b/api/tests/integration/tests/formats/idt_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -71,16 +66,7 @@ def find_diff(a, b): for filename in sorted(idt_data.keys()): mol = indigo.loadIdt(idt_data[filename], lib) ket = mol.json() - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) idt_errors = { "!+A-$#12w12r23e32e33": "Invalid symbols in the sequence: !,-,$,#,1,2,w,1,2,2,3,e,3,2,e,3,3", diff --git a/api/tests/integration/tests/formats/ket_ambiguous_export.py b/api/tests/integration/tests/formats/ket_ambiguous_export.py index ca6004ab58..07c49fd28b 100644 --- a/api/tests/integration/tests/formats/ket_ambiguous_export.py +++ b/api/tests/integration/tests/formats/ket_ambiguous_export.py @@ -1,12 +1,6 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") diff --git a/api/tests/integration/tests/formats/ket_bad_stereo.py b/api/tests/integration/tests/formats/ket_bad_stereo.py index 24969d0080..fde55739d7 100644 --- a/api/tests/integration/tests/formats/ket_bad_stereo.py +++ b/api/tests/integration/tests/formats/ket_bad_stereo.py @@ -1,12 +1,6 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") diff --git a/api/tests/integration/tests/formats/ket_cdxml.py b/api/tests/integration/tests/formats/ket_cdxml.py index 1a9f3076ea..367f82169e 100644 --- a/api/tests/integration/tests/formats/ket_cdxml.py +++ b/api/tests/integration/tests/formats/ket_cdxml.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -52,6 +47,7 @@ def find_diff(a, b): raise SystemExit cdxml_text = ket.cdxml() + compare_diff(ref_path, filename + ".cdxml", cdxml_text) try: ket = indigo.loadMolecule(cdxml_text) @@ -59,28 +55,7 @@ def find_diff(a, b): ket = indigo.loadReaction(cdxml_text) ket_result = ket.json() - - # with open(os.path.join(ref_path, filename + ".ket"), "w") as file: - # file.write(ket_result) - # with open(os.path.join(ref_path, filename + ".cdxml"), "w") as file: - # file.write(cdxml_text) - - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() - with open(os.path.join(ref_path, filename) + ".cdxml", "r") as file: - cdxml_ref = file.read() - diff = find_diff(cdxml_ref, cdxml_text) - if not diff: - print(filename + ".cdxml:SUCCEED") - else: - print(filename + ".cdxml:FAILED") - print(diff) - diff = find_diff(ket_ref, ket_result) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket_result) print("*** KET to CDXML ***") @@ -101,20 +76,10 @@ def find_diff(a, b): print(getIndigoExceptionText(e)) raise SystemExit cdxml_text = ket.cdxml() - # with open(os.path.join(ref_path, filename) + ".cdxml", "w") as file: - # file.write(cdxml_text) - indigo.loadMolecule( cdxml_text ) # just check if cdxml is valid and loaded without an exception - with open(os.path.join(ref_path, filename) + ".cdxml", "r") as file: - cdxml_ref = file.read() - diff = find_diff(cdxml_ref, cdxml_text) - if not diff: - print(filename + ".cdxml:SUCCEED") - else: - print(filename + ".cdxml:FAILED") - print(diff) + compare_diff(ref_path, filename + ".cdxml", cdxml_text) print("*** Reaction CDXML to KET ***") indigo.setOption("ignore-stereochemistry-errors", True) @@ -132,15 +97,6 @@ def find_diff(a, b): try: reaction = indigo.loadReaction(cdxml_str) ket_result = reaction.json() - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(ket_result) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, ket_result) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket_result) except IndigoException as e: print(e) diff --git a/api/tests/integration/tests/formats/ket_retrosynthetic_arrow.py b/api/tests/integration/tests/formats/ket_retrosynthetic_arrow.py index c527fbbbb0..82268ed40a 100644 --- a/api/tests/integration/tests/formats/ket_retrosynthetic_arrow.py +++ b/api/tests/integration/tests/formats/ket_retrosynthetic_arrow.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -80,46 +75,16 @@ def getCML(reaction): ) for format_name, format_postfix, get_format_func in output_formats: filename = test_case_filename + format_postfix - parsed_format = get_format_func(rc) - print("output format: " + format_name) - - # with open(os.path.join(ref_path, filename), "w") as file: - # file.write(parsed_format) - - with open(os.path.join(ref_path, filename), "r") as file: - format_ref = file.read() - - diff = find_diff(format_ref, parsed_format) - if not diff: - print(filename + ":SUCCEED") - else: - print(filename + ":FAILED") - print(diff) + compare_diff(ref_path, filename, parsed_format) print("issue 2318") indigo.setOption("json-use-native-precision", "1") filename = "ket_retro_arrow.ket" fname = os.path.join(root_rea, filename) rxn = indigo.loadReactionFromFile(fname) -# with open(fname, "w") as file: -# file.write(rxn.json()) -with open(fname, "r") as file: - ref_json = file.read() -diff = find_diff(ref_json, rxn.json()) -if not diff: - print(filename + ":SUCCEED") -else: - print(filename + ":FAILED") - print(diff) +compare_diff(ref_path, filename, rxn.json()) print("issue 2417") rxn.layout() -# with open(fname, "w") as file: -# file.write(rxn.json()) -diff = find_diff(ref_json, rxn.json()) -if not diff: - print(filename + ":SUCCEED") -else: - print(filename + ":FAILED") - print(diff) +compare_diff(ref_path, filename, rxn.json()) diff --git a/api/tests/integration/tests/formats/ket_to_axolabs.py b/api/tests/integration/tests/formats/ket_to_axolabs.py index 44b5b84ba8..b8edb954c8 100644 --- a/api/tests/integration/tests/formats/ket_to_axolabs.py +++ b/api/tests/integration/tests/formats/ket_to_axolabs.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import find_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -44,13 +39,12 @@ def find_diff(a, b): try: axolabs = mol.axolabs(lib) axolabs_ref = axolabs_data[filename] - if axolabs_ref == axolabs: + diff = find_diff(axolabs_ref, axolabs) + if not diff: print(filename + ".ket:SUCCEED") else: - print( - "%s FAILED : expected '%s', got '%s'" - % (filename, axolabs_ref, axolabs) - ) + print(filename + ".ket:FAILED") + print(diff) except IndigoException as e: text = getIndigoExceptionText(e) print(filename + ".ket:FAILED - %s" % text) diff --git a/api/tests/integration/tests/formats/ket_to_cml.py b/api/tests/integration/tests/formats/ket_to_cml.py index 87b9b4cbc0..f45502a168 100644 --- a/api/tests/integration/tests/formats/ket_to_cml.py +++ b/api/tests/integration/tests/formats/ket_to_cml.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -35,16 +30,5 @@ def find_diff(a, b): ket = indigo.loadQueryMoleculeFromFile( os.path.join(root, filename + ".ket") ) - cml = ket.cml() - # with open(os.path.join(ref_path, filename) + ".cml", "w") as file: - # file.write(cml) - - with open(os.path.join(ref_path, filename) + ".cml", "r") as file: - cml_ref = file.read() - diff = find_diff(cml_ref, cml) - if not diff: - print(filename + ".cml:SUCCEED") - else: - print(filename + ".cml:FAILED") - print(diff) + compare_diff(ref_path, filename + ".cml", cml) diff --git a/api/tests/integration/tests/formats/ket_to_fasta.py b/api/tests/integration/tests/formats/ket_to_fasta.py index 4e3a930f32..6733dc0adc 100644 --- a/api/tests/integration/tests/formats/ket_to_fasta.py +++ b/api/tests/integration/tests/formats/ket_to_fasta.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -38,14 +33,5 @@ def find_diff(a, b): files.sort() for filename in files: mol = indigo.loadKetDocumentFromFile(os.path.join(root, filename + ".ket")) - # with open(os.path.join(ref_path, filename) + ".fasta", "w") as file: - # file.write(mol.fasta(lib)) - with open(os.path.join(ref_path, filename) + ".fasta", "r") as file: - seq_ref = file.read() seq = mol.fasta(lib) - diff = find_diff(seq_ref, seq) - if not diff: - print(filename + ".fasta:SUCCEED") - else: - print(filename + ".fasta:FAILED") - print(diff) + compare_diff(ref_path, filename + ".fasta", seq) diff --git a/api/tests/integration/tests/formats/ket_to_helm.py b/api/tests/integration/tests/formats/ket_to_helm.py index a63cd229ed..d8ade7d9d4 100644 --- a/api/tests/integration/tests/formats/ket_to_helm.py +++ b/api/tests/integration/tests/formats/ket_to_helm.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import find_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -81,13 +76,12 @@ def find_diff(a, b): continue helm_ref = helm_data[filename] - if helm_ref == helm: + diff = find_diff(helm_ref, helm) + if not diff: print(filename + ".ket:SUCCEED") else: - print( - "%s.ket FAILED : expected '%s', got '%s'" - % (filename, helm_ref, helm) - ) + print(filename + ".ket:FAILED") + print(diff) helm_errors = {} for filename in sorted(helm_errors.keys()): diff --git a/api/tests/integration/tests/formats/ket_to_idt.py b/api/tests/integration/tests/formats/ket_to_idt.py index 06b03c175f..6c19e3c838 100644 --- a/api/tests/integration/tests/formats/ket_to_idt.py +++ b/api/tests/integration/tests/formats/ket_to_idt.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import find_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -78,13 +73,12 @@ def find_diff(a, b): try: idt = mol.idt(lib) idt_ref = idt_data[filename] - if idt_ref == idt: + diff = find_diff(idt_ref, idt) + if not diff: print(filename + ".ket:SUCCEED") else: - print( - "%s.idt FAILED : expected '%s', got '%s'" - % (filename, idt_ref, idt) - ) + print(filename + ".ket:FAILED") + print(diff) except IndigoException as e: text = getIndigoExceptionText(e) print(filename + ".ket:FAILED - %s" % text) diff --git a/api/tests/integration/tests/formats/ket_to_ket.py b/api/tests/integration/tests/formats/ket_to_ket.py index 71f8759def..2eb626cbd1 100644 --- a/api/tests/integration/tests/formats/ket_to_ket.py +++ b/api/tests/integration/tests/formats/ket_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -40,28 +35,8 @@ def find_diff(a, b): mol = indigo.loadQueryMoleculeFromFile( os.path.join(root, filename + ".ket") ) - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) - - -def check_res(filename, format, ket_ref, ket): - diff = find_diff(ket_ref, ket) - if not diff: - print("{}.ket {}: SUCCEED".format(filename, format)) - else: - print("{}.ket {}: FAILED".format(filename, format)) - print(diff) - + compare_diff(ref_path, filename + ".ket", ket) indigo.setOption("json-use-native-precision", True) files = [ @@ -79,15 +54,19 @@ def check_res(filename, format, ket_ref, ket): } for filename in sorted(files): for format in sorted(savers.keys()): - file_path = os.path.join(ref_path, filename) - with open("{}_{}.ket".format(file_path, format), "r") as file: + _filename = "{}_{}.ket".format(filename, format) + file_path = os.path.join(ref_path, _filename) + with open(file_path, "r") as file: ket_ref = file.read() for loader in savers[format]: mol = loader(ket_ref) - # with open("{}_{}.ket".format(file_path, format), "w") as file: - # file.write(mol.json()) ket = mol.json() - check_res(filename, format + " " + loader.__name__, ket_ref, ket) + diff = compare_diff(ref_path, _filename, ket, stdout=False) + if not diff: + print("{} {}:SUCCEED".format(_filename, loader.__name__)) + else: + print("{} {}:FAILED".format(_filename, loader.__name__)) + print(diff) filename = "2707_subst_count" file_path = os.path.join(ref_path, filename) @@ -95,11 +74,8 @@ def check_res(filename, format, ket_ref, ket): savers = {"ket": mol.json, "mol": mol.molfile} for format in sorted(savers.keys()): data = savers[format]() - # with open("{}.{}".format(file_path, format), "w") as file: - # file.write(data) - with open("{}.{}".format(file_path, format), "r") as file: - data_ref = file.read() - check_res(filename, format, data_ref, data) + _filename = filename + ".{}".format(format) + compare_diff(ref_path, _filename, data) files = ["multi_merge4", "3069-reaction"] @@ -116,18 +92,8 @@ def check_res(filename, format, ket_ref, ket): ) except: print("bad reaction data") - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(rea.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = rea.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) # reaction data files = [ @@ -145,15 +111,5 @@ def check_res(filename, format, ket_ref, ket): rea = indigo.loadReactionFromFile( os.path.join(root_rea, filename + ".ket") ) - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(rea.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = rea.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) diff --git a/api/tests/integration/tests/formats/ket_to_mol.py b/api/tests/integration/tests/formats/ket_to_mol.py index db9c2ed205..f291739167 100644 --- a/api/tests/integration/tests/formats/ket_to_mol.py +++ b/api/tests/integration/tests/formats/ket_to_mol.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, IndigoException, joinPathPy # noqa indigo = Indigo() @@ -100,19 +95,8 @@ def find_diff(a, b): if len(test_tuple) > 1: indigo.setOption("molfile-saving-mode", test_tuple[1]) - - # with open(os.path.join(ref_path, filename) + ".mol", "w") as file: - # file.write(mol.molfile()) - - with open(os.path.join(ref_path, filename) + ".mol", "r") as file: - ket_ref = file.read() ket = mol.molfile() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".mol", ket) files = ["ket-reaction-arrow", "empty_apid"] @@ -120,14 +104,4 @@ def find_diff(a, b): for filename in files: rc = indigo.loadReactionFromFile(os.path.join(root_rea, filename + ".ket")) ket = rc.rxnfile() - # with open(os.path.join(ref_path, filename) + ".mol", "w") as file: - # file.write(ket) - - with open(os.path.join(ref_path, filename) + ".mol", "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".mol", ket) diff --git a/api/tests/integration/tests/formats/ket_to_rdf.py b/api/tests/integration/tests/formats/ket_to_rdf.py index a1ec6faba5..135ac4e348 100644 --- a/api/tests/integration/tests/formats/ket_to_rdf.py +++ b/api/tests/integration/tests/formats/ket_to_rdf.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( Indigo, IndigoException, @@ -78,16 +73,4 @@ def find_diff(a, b): rdfSaver.append(rxn.clone()) rdfSaver.close() rdf = buffer.toString() - - # with open(os.path.join(ref_path, filename) + ".rdf", "w") as file: - # file.write(rdf) - - with open(os.path.join(ref_path, filename) + ".rdf", "r") as file: - rdf_ref = file.read() - - diff = find_diff(rdf_ref, rdf) - if not diff: - print(filename + ".rdf:SUCCEED") - else: - print(filename + ".rdf:FAILED") - print(diff) + compare_diff(ref_path, filename + ".rdf", rdf) diff --git a/api/tests/integration/tests/formats/ket_to_rxn.py b/api/tests/integration/tests/formats/ket_to_rxn.py index 68f5230e76..29c0815410 100644 --- a/api/tests/integration/tests/formats/ket_to_rxn.py +++ b/api/tests/integration/tests/formats/ket_to_rxn.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -42,15 +37,5 @@ def find_diff(a, b): files.sort() for filename in files: rea = indigo.loadReactionFromFile(os.path.join(root, filename + ".ket")) - - # with open(os.path.join(ref_path, filename) + ".rxn", "w") as file: - # file.write(rea.rxnfile()) - with open(os.path.join(ref_path, filename) + ".rxn", "r") as file: - rxn_ref = file.read() rxn = rea.rxnfile() - diff = find_diff(rxn_ref, rxn) - if not diff: - print(filename + ".rxn:SUCCEED") - else: - print(filename + ".rxn:FAILED") - print(diff) + compare_diff(ref_path, filename + ".rxn", rxn) diff --git a/api/tests/integration/tests/formats/ket_to_sdf.py b/api/tests/integration/tests/formats/ket_to_sdf.py index 886ea4fac5..cd2ee7f77c 100644 --- a/api/tests/integration/tests/formats/ket_to_sdf.py +++ b/api/tests/integration/tests/formats/ket_to_sdf.py @@ -1,12 +1,7 @@ -import difflib -import os +import os import sys -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - def expect_monomer_library_load_error(root, filename, expected_error): try: indigo.loadMonomerLibraryFromFile( @@ -28,6 +23,7 @@ def expect_monomer_library_load_error(root, filename, expected_error): os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -63,17 +59,7 @@ def expect_monomer_library_load_error(root, filename, expected_error): sdfSaver.append(frag.clone()) sdfSaver.close() sdf = buffer.toString() - # with open(os.path.join(ref_path, filename) + ".sdf", "w") as file: - # file.write(sdf) - - with open(os.path.join(ref_path, filename) + ".sdf", "r") as file: - sdf_ref = file.read() - diff = find_diff(sdf_ref, sdf) - if not diff: - print(filename + ".sdf:SUCCEED") - else: - print(filename + ".sdf:FAILED") - print(diff) + compare_diff(ref_path, filename + ".sdf", sdf) root = joinPathPy("reactions/", __file__) ref_path = joinPathPy("ref/", __file__) @@ -100,17 +86,7 @@ def expect_monomer_library_load_error(root, filename, expected_error): sdfSaver.append(mol.clone()) sdfSaver.close() sdf = buffer.toString() - # with open(os.path.join(ref_path, filename) + ".sdf", "w") as file: - # file.write(sdf) - - with open(os.path.join(ref_path, filename) + ".sdf", "r") as file: - sdf_ref = file.read() - diff = find_diff(sdf_ref, sdf) - if not diff: - print(filename + ".sdf:SUCCEED") - else: - print(filename + ".sdf:FAILED") - print(diff) + compare_diff(ref_path, filename + ".sdf", sdf) print("*** KET-monomer library to SDF ***") root = joinPathPy("molecules/", __file__) @@ -130,17 +106,8 @@ def expect_monomer_library_load_error(root, filename, expected_error): lib = indigo.loadMonomerLibraryFromFile( os.path.join(root, filename + ".ket") ) - # with open(os.path.join(ref_path, filename) + ".sdf", "w") as file: - # file.write(lib.monomerLibrary()) - with open(os.path.join(ref_path, filename) + ".sdf", "r") as file: - sdf_ref = file.read() sdf = lib.monomerLibrary() - diff = find_diff(sdf_ref, sdf) - if not diff: - print(filename + ".sdf:SUCCEED") - else: - print(filename + ".sdf:FAILED") - print(diff) + compare_diff(ref_path, filename + ".sdf", sdf) print("*** Invalid KET-monomer library to SDF ***") expect_monomer_library_load_error( diff --git a/api/tests/integration/tests/formats/ket_to_seq3letter.py b/api/tests/integration/tests/formats/ket_to_seq3letter.py index 8d8d905fdd..ba04260d6c 100644 --- a/api/tests/integration/tests/formats/ket_to_seq3letter.py +++ b/api/tests/integration/tests/formats/ket_to_seq3letter.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -37,17 +32,8 @@ def find_diff(a, b): files.sort() for filename in files: doc = indigo.loadKetDocumentFromFile(os.path.join(refp, filename + ".ket")) - # with open(os.path.join(refp, filename) + ".seq3", "w") as file: - # file.write(doc.sequence3Letter(lib)) - with open(os.path.join(refp, filename) + ".seq3", "r") as file: - seq_ref = file.read() seq = doc.sequence3Letter(lib) - diff = find_diff(seq_ref, seq) - if not diff: - print(filename + " : SUCCEED") - else: - print(filename + " : FAILED") - print(diff) + compare_diff(refp, filename + ".seq3", seq) seq_errors = { "peptides_molecule": "Sequence saver: Can't save micro-molecules to sequence format", diff --git a/api/tests/integration/tests/formats/ket_w_mult_group2mol.py b/api/tests/integration/tests/formats/ket_w_mult_group2mol.py index 2821159e95..079661468b 100644 --- a/api/tests/integration/tests/formats/ket_w_mult_group2mol.py +++ b/api/tests/integration/tests/formats/ket_w_mult_group2mol.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -31,14 +26,5 @@ def find_diff(a, b): files.sort() for filename in files: mol = indigo.loadMoleculeFromFile(os.path.join(root, filename + ".ket")) - # with open(os.path.join(ref_path, filename) + ".mol", "w") as file: - # mol_ref = file.write(mol.molfile()) - with open(os.path.join(ref_path, filename) + ".mol", "r") as file: - mol_ref = file.read() ket = mol.molfile() - diff = find_diff(mol_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".mol", ket) diff --git a/api/tests/integration/tests/formats/ket_with_query.py b/api/tests/integration/tests/formats/ket_with_query.py index 68e17e34e7..bce6b67033 100644 --- a/api/tests/integration/tests/formats/ket_with_query.py +++ b/api/tests/integration/tests/formats/ket_with_query.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -21,18 +16,9 @@ def find_diff(a, b): def check_ket_file(name): - filename = os.path.join(ref_path, name) - - mol = indigo.loadQueryMoleculeFromFile(filename) - with open(filename, "r") as file: - ket_ref = file.read() + mol = indigo.loadQueryMoleculeFromFile(os.path.join(ref_path, name)) ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(name + ":SUCCEED") - else: - print(name + ":FAILED") - print(diff) + compare_diff(ref_path, name, ket) print("*** KET with query components ***") diff --git a/api/tests/integration/tests/formats/macromol_props.py b/api/tests/integration/tests/formats/macromol_props.py index c5008ae668..ae742703a6 100644 --- a/api/tests/integration/tests/formats/macromol_props.py +++ b/api/tests/integration/tests/formats/macromol_props.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff, find_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -72,16 +67,7 @@ def find_diff(a, b): except Exception as e: print("Test '%s' failed: %", (filename, e)) continue - # with open(os.path.join(ref, filename) + ".json", "w") as file: - # file.write(props) - with open(os.path.join(ref, filename) + ".json", "r") as file: - props_ref = file.read() - diff = find_diff(props_ref, props) - if not diff: - print(filename + ".json: SUCCEED") - else: - print(filename + ".json: FAILED") - print(diff) + compare_diff(ref, filename + ".json", props) filename = "props_double_dna_gc" mol = indigo.loadKetDocumentFromFile(os.path.join(root, filename + ".ket")) diff --git a/api/tests/integration/tests/formats/mol_features.py b/api/tests/integration/tests/formats/mol_features.py index d2f0dc8bc8..dcf372f265 100644 --- a/api/tests/integration/tests/formats/mol_features.py +++ b/api/tests/integration/tests/formats/mol_features.py @@ -1,4 +1,3 @@ -import difflib import os import sys @@ -7,6 +6,7 @@ os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import find_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -31,19 +31,16 @@ def trim_sed(s): return s -def find_diff(a, b): - return "\n".join( - difflib.unified_diff( - [trim_sed(s) for s in a.splitlines()], - [trim_sed(s) for s in b.splitlines()], - ) - ) +def reconstruct_file(t): + return "\n".join(trim_sed(s) for s in t.splitlines()) def testReload(mol): - molfile = mol.molfile() - mol2 = indigo.loadMolecule(molfile) - molfile2 = mol2.molfile() + molfile_with_sed = mol.molfile() + mol2 = indigo.loadMolecule(molfile_with_sed) + molfile2_with_sed = mol2.molfile() + molfile = reconstruct_file(molfile_with_sed) + molfile2 = reconstruct_file(molfile2_with_sed) diff = find_diff(molfile, molfile2) if diff: print("Molecule is different after resave") diff --git a/api/tests/integration/tests/formats/mol_to_ket.py b/api/tests/integration/tests/formats/mol_to_ket.py index 8bbee22eb5..356c55725b 100644 --- a/api/tests/integration/tests/formats/mol_to_ket.py +++ b/api/tests/integration/tests/formats/mol_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -103,14 +98,5 @@ def find_diff(a, b): indigo.setOption("json-use-native-precision", True) else: indigo.setOption("json-use-native-precision", False) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) diff --git a/api/tests/integration/tests/formats/mol_to_seq.py b/api/tests/integration/tests/formats/mol_to_seq.py index 876d782c0b..979f09220a 100644 --- a/api/tests/integration/tests/formats/mol_to_seq.py +++ b/api/tests/integration/tests/formats/mol_to_seq.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -45,18 +40,9 @@ def find_diff(a, b): files.sort() for filename in files: mol = indigo.loadMoleculeFromFile(os.path.join(root, filename + ".mol")) - # with open(os.path.join(ref_path, filename) + ".seq", "w") as file: - # file.write(mol.sequence()) - with open(os.path.join(ref_path, filename) + ".seq", "r") as file: - seq_ref = file.read() try: seq = mol.sequence(lib) - diff = find_diff(seq_ref, seq) - if not diff: - print(filename + ".seq:SUCCEED") - else: - print(filename + ".seq:FAILED") - print(diff) + compare_diff(ref_path, filename + ".seq", seq) except IndigoException as e: text_exception = getIndigoExceptionText(e) if ( diff --git a/api/tests/integration/tests/formats/pathway.py b/api/tests/integration/tests/formats/pathway.py index d5a3a55e2a..def93cff7d 100644 --- a/api/tests/integration/tests/formats/pathway.py +++ b/api/tests/integration/tests/formats/pathway.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * indigo = Indigo() @@ -38,17 +33,5 @@ def find_diff(a, b): rxn = indigo.loadReactionFromFile( os.path.join(input_path, filename + ".rdf") ) - rxn_txt = rxn.json() - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(rxn_txt) - - rxn_ref = open(getRefFilepath(filename + ".ket"), "r").read() - - diff = find_diff(rxn_ref, rxn_txt) - if not diff: - print(filename + ".rdf:SUCCEED") - else: - print(filename + ".rdf:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", rxn_txt) diff --git a/api/tests/integration/tests/formats/pathway_ops.py b/api/tests/integration/tests/formats/pathway_ops.py index 19d9bc1125..ea3b3a44a4 100644 --- a/api/tests/integration/tests/formats/pathway_ops.py +++ b/api/tests/integration/tests/formats/pathway_ops.py @@ -1,17 +1,12 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * indigo = Indigo() @@ -42,27 +37,21 @@ def find_diff(a, b): # aromatize check rxn.aromatize() rxn_txt = rxn.json() - # with open(os.path.join(ref_path_arom, filename) + ".ket", "w") as file: - # file.write(rxn_txt) - - rxn_ref = open(os.path.join(ref_path_arom, filename) + ".ket", "r").read() - diff_arom = find_diff(rxn_ref, rxn_txt) + diff_arom = compare_diff( + ref_path_arom, filename + ".ket", rxn_txt, stdout=False + ) # dearomatize check rxn.dearomatize() rxn_txt = rxn.json() - # with open(os.path.join(ref_path_dearom, filename) + ".ket", "w") as file: - # file.write(rxn_txt) - - rxn_ref = open( - os.path.join(ref_path_dearom, filename) + ".ket", "r" - ).read() - diff_dearom = find_diff(rxn_ref, rxn_txt) + diff_dearom = compare_diff( + ref_path_dearom, filename + ".ket", rxn_txt, stdout=False + ) diff = diff_arom and diff_dearom if not diff: - print(filename + ".rdf:SUCCEED") + print(filename + ".ket:SUCCEED") else: - print(filename + ".rdf:FAILED") + print(filename + ".ket:FAILED") print(diff) diff --git a/api/tests/integration/tests/formats/reactions_to_cdxml.py b/api/tests/integration/tests/formats/reactions_to_cdxml.py index d85aec8c57..50bad18c00 100644 --- a/api/tests/integration/tests/formats/reactions_to_cdxml.py +++ b/api/tests/integration/tests/formats/reactions_to_cdxml.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -53,42 +48,19 @@ def find_diff(a, b): print(" %s" % (getIndigoExceptionText(e))) cdxml_text = ket.cdxml() - # with open(os.path.join(ref_path, filename + ".cdxml"), "w") as file: - # file.write(cdxml_text) - - with open(os.path.join(ref_path, filename) + ".cdxml", "r") as file: - cdxml_ref = file.read() - - diff = find_diff(cdxml_ref, cdxml_text) - if not diff: - print(filename + ".cdxml:SUCCEED") - else: - print(filename + ".cdxml:FAILED") - print(diff) - - -def compare_cdxml_with_reference(cdxml_text, reference_file): - with open(os.path.join(ref_path, reference_file), "r") as file: - cdxml_ref = file.read() - diff = find_diff(cdxml_ref, cdxml_text) - if not diff: - print(reference_file + ":SUCCEED") - else: - print(reference_file + ":FAILED") - print(diff) - + compare_diff(ref_path, filename + ".cdxml", cdxml_text) reaction = indigo.loadReactionFromFile( os.path.join(root, "3261_cdxml_reaction_molecule.cdxml") ) for reactant in reaction.iterateReactants(): cdxml_text = reactant.cdxml() - compare_cdxml_with_reference(cdxml_text, "3261_ref1.cdxml") + compare_diff(ref_path, "3261_ref1.cdxml", cdxml_text) for catalyst in reaction.iterateCatalysts(): cdxml_text = catalyst.cdxml() - compare_cdxml_with_reference(cdxml_text, "3261_ref2.cdxml") + compare_diff(ref_path, "3261_ref2.cdxml", cdxml_text) for product in reaction.iterateProducts(): cdxml_text = product.cdxml() - compare_cdxml_with_reference(cdxml_text, "3261_ref3.cdxml") + compare_diff(ref_path, "3261_ref3.cdxml", cdxml_text) diff --git a/api/tests/integration/tests/formats/reactions_to_ket.py b/api/tests/integration/tests/formats/reactions_to_ket.py index b342fc47ed..6238fa5266 100644 --- a/api/tests/integration/tests/formats/reactions_to_ket.py +++ b/api/tests/integration/tests/formats/reactions_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -40,16 +35,5 @@ def find_diff(a, b): except: print("bad reaction data") - # with open(os.path.join(ref_path, test[1]) + ".ket", "w") as file: - # file.write(reaction.json()) - - with open(os.path.join(ref_path, test[1]) + ".ket", "r") as file: - ket_ref = file.read() - ket = reaction.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(test[1] + ".ket:SUCCEED") - else: - print(test[1] + ".ket:FAILED") - print(diff) + compare_diff(ref_path, test[1] + ".ket", ket) diff --git a/api/tests/integration/tests/formats/ref/ket_retro_arrow.ket b/api/tests/integration/tests/formats/ref/ket_retro_arrow.ket new file mode 100644 index 0000000000..f0d8784d07 --- /dev/null +++ b/api/tests/integration/tests/formats/ref/ket_retro_arrow.ket @@ -0,0 +1,135 @@ +{ + "root": { + "nodes": [ + { + "$ref": "mol0" + }, + { + "$ref": "mol1" + }, + { + "type": "arrow", + "data": { + "mode": "retrosynthetic", + "pos": [ + { + "x": 3.232051, + "y": 0.0, + "z": 0.0 + }, + { + "x": 4.232051, + "y": 0.0, + "z": 0.0 + } + ] + } + } + ] + }, + "mol0": { + "type": "molecule", + "atoms": [ + { + "label": "O", + "location": [ + 5.232051, + 0.25, + 0.0 + ] + }, + { + "label": "C", + "location": [ + 6.098076, + -0.25, + 0.0 + ] + }, + { + "label": "O", + "location": [ + 6.964102, + 0.25, + 0.0 + ] + } + ], + "bonds": [ + { + "type": 1, + "atoms": [ + 0, + 1 + ] + }, + { + "type": 1, + "atoms": [ + 1, + 2 + ] + } + ] + }, + "mol1": { + "type": "molecule", + "atoms": [ + { + "label": "C", + "location": [ + 1.366025, + -0.75, + 0.0 + ] + }, + { + "label": "C", + "location": [ + 1.366025, + 0.25, + 0.0 + ] + }, + { + "label": "C", + "location": [ + 0.5, + 0.75, + 0.0 + ] + }, + { + "label": "N", + "location": [ + 2.232051, + 0.75, + 0.0 + ] + } + ], + "bonds": [ + { + "type": 1, + "atoms": [ + 0, + 1 + ] + }, + { + "type": 1, + "atoms": [ + 1, + 2 + ] + }, + { + "type": 1, + "atoms": [ + 1, + 3 + ] + } + ] + } +} \ No newline at end of file diff --git a/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdx.py b/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdx.py index 9914c783bb..80648c222a 100644 --- a/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdx.py +++ b/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdx.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -46,20 +41,5 @@ def find_diff(a, b): rc = indigo.loadReactionFromFile( os.path.join(root_rea, test_case_filename + ".ket") ) - - filename = test_case_filename + ".b64cdx" - cdx_b64 = rc.b64cdx() - - # with open(os.path.join(ref_path, filename), "w") as file: - # file.write(cdx_b64) - - with open(os.path.join(ref_path, filename), "r") as file: - cdx_b64_ref = file.read() - - diff = find_diff(cdx_b64_ref, cdx_b64) - if not diff: - print(filename + ":SUCCEED") - else: - print(filename + ":FAILED") - print(diff) + compare_diff(ref_path, test_case_filename + ".b64cdx", cdx_b64) diff --git a/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdxml.py b/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdxml.py index 04db9027f3..6cc5cb1d5b 100644 --- a/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdxml.py +++ b/api/tests/integration/tests/formats/retrosynthetic_arrow_to_cdxml.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -47,20 +42,5 @@ def find_diff(a, b): rc = indigo.loadReactionFromFile( os.path.join(root_rea, test_case_filename + ".ket") ) - - filename = test_case_filename + ".cdxml" - cdxml_text = rc.cdxml() - - # with open(os.path.join(ref_path, filename), "w") as file: - # file.write(cdxml_text) - - with open(os.path.join(ref_path, filename), "r") as file: - format_ref = file.read() - - diff = find_diff(format_ref, cdxml_text) - if not diff: - print(filename + ":SUCCEED") - else: - print(filename + ":FAILED") - print(diff) + compare_diff(ref_path, test_case_filename + ".cdxml", cdxml_text) diff --git a/api/tests/integration/tests/formats/rxn_to_ket.py b/api/tests/integration/tests/formats/rxn_to_ket.py index ea38cb3f60..8a3b052a36 100644 --- a/api/tests/integration/tests/formats/rxn_to_ket.py +++ b/api/tests/integration/tests/formats/rxn_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy # noqa indigo = Indigo() @@ -34,15 +29,5 @@ def find_diff(a, b): files.sort() for filename in files: mol = indigo.loadReactionFromFile(os.path.join(root, filename + ".rxn")) - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) diff --git a/api/tests/integration/tests/formats/sdf_to_ket.py b/api/tests/integration/tests/formats/sdf_to_ket.py index 858e54c48f..4a64dfeea9 100644 --- a/api/tests/integration/tests/formats/sdf_to_ket.py +++ b/api/tests/integration/tests/formats/sdf_to_ket.py @@ -1,12 +1,7 @@ -import difflib -import os +import os import sys -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - def expect_monomer_library_load_error(root, filename, expected_error): try: indigo.loadMonomerLibraryFromFile( @@ -28,6 +23,7 @@ def expect_monomer_library_load_error(root, filename, expected_error): os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -54,17 +50,8 @@ def expect_monomer_library_load_error(root, filename, expected_error): ) except IndigoException as e: print(" %s" % (getIndigoExceptionText(e))) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) print("*** SDF-monomer library to KET ***") files = [ @@ -86,17 +73,8 @@ def expect_monomer_library_load_error(root, filename, expected_error): lib = indigo.loadMonomerLibraryFromFile( os.path.join(root, filename + ".sdf") ) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(lib.monomerLibrary()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = lib.monomerLibrary() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) print("*** Invalid SDF-monomer library to KET ***") expect_monomer_library_load_error( diff --git a/api/tests/integration/tests/formats/seq3letter_to_ket.py b/api/tests/integration/tests/formats/seq3letter_to_ket.py index 8a33a7e1fa..b3c5846e74 100644 --- a/api/tests/integration/tests/formats/seq3letter_to_ket.py +++ b/api/tests/integration/tests/formats/seq3letter_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( # noqa Indigo, IndigoException, @@ -41,17 +36,8 @@ def find_diff(a, b): doc = indigo.loadSequenceFromFile( os.path.join(ref_path, filename + ".seq3"), "PEPTIDE-3-LETTER", lib ) - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(doc.json()) - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = doc.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + " : SUCCEED") - else: - print(filename + " : FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) seq3_errors = { "ala": "Given string cannot be interpreted as a valid three letter sequence because of incorrect formatting.", diff --git a/api/tests/integration/tests/formats/seq_to_ket.py b/api/tests/integration/tests/formats/seq_to_ket.py index bbf5ced1bb..7d6b5c0fc3 100644 --- a/api/tests/integration/tests/formats/seq_to_ket.py +++ b/api/tests/integration/tests/formats/seq_to_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import ( Indigo, IndigoException, @@ -52,18 +47,8 @@ def find_diff(a, b): for seq in seq_tests: mol = indigo.loadSequence(seq["seq_data"], seq["seq_type"], lib) filename = seq["ref"] - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) seq_errors = { "12w12r23e32e33": ( diff --git a/api/tests/integration/tests/formats/serialize_deserialize_attachment_points_in_ket.py b/api/tests/integration/tests/formats/serialize_deserialize_attachment_points_in_ket.py index f61d06c102..30b57a1d45 100644 --- a/api/tests/integration/tests/formats/serialize_deserialize_attachment_points_in_ket.py +++ b/api/tests/integration/tests/formats/serialize_deserialize_attachment_points_in_ket.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -41,17 +36,8 @@ def find_diff(a, b): ket_in = indigo.loadMoleculeFromFile( os.path.join(root, filename + ".ket") ) - with open( - os.path.join(ref_path, filename) + "_out" + ".ket", "r" - ) as file: - ket_ref = file.read() ket = ket_in.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + "_out" + ".ket", ket) except IndigoException as e: print(getIndigoExceptionText(e)) @@ -59,11 +45,5 @@ def find_diff(a, b): mol_files.sort() for filename in mol_files: mol_in = indigo.loadMoleculeFromFile(os.path.join(root, filename + ".mol")) - with open(os.path.join(ref_path, filename) + "_out" + ".mol", "r") as file: - mol_ref = file.read() - diff = find_diff(mol_ref, mol_in.molfile()) - if not diff: - print(filename + ".mol:SUCCEED") - else: - print(filename + ".mol:FAILED") - print(diff) + mol = mol_in.molfile() + compare_diff(ref_path, filename + "_out" + ".mol", mol) diff --git a/api/tests/integration/tests/layout/acs_style_reaction.py b/api/tests/integration/tests/layout/acs_style_reaction.py index efdb670922..7aedf87650 100644 --- a/api/tests/integration/tests/layout/acs_style_reaction.py +++ b/api/tests/integration/tests/layout/acs_style_reaction.py @@ -1,4 +1,3 @@ -import difflib import os import sys @@ -7,13 +6,9 @@ os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import Indigo, joinPathPy, reactionLayoutDiff # noqa - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - indigo = Indigo() indigo.setOption("molfile-saving-skip-date", "1") indigo.setOption("json-saving-pretty", "1") @@ -22,22 +17,15 @@ def find_diff(a, b): root = joinPathPy("reactions/", __file__) ref = joinPathPy("ref/", __file__) -upd = False - print("*** ACS reaction layout testing ***") print("\n*** test zero margin ***") rxn = indigo.loadReactionFromFile(os.path.join(root, "acs_before_layout.ket")) indigo.setOption("reaction-component-margin-size", "0.0") rxn.layout() - -# with open(os.path.join(ref, "acs_after_layout_zero_margin.ket"), "w") as file: -# file.write(rxn.json()) - res = reactionLayoutDiff( indigo, rxn, "acs_after_layout_zero_margin.ket", - update=upd, update_format="ket", ) print(" Result: {}".format(res)) @@ -47,15 +35,10 @@ def find_diff(a, b): indigo.setOption("bond-length", "40.0") indigo.setOption("reaction-component-margin-size", "20.0") rxn.layout() - -# with open(os.path.join(ref, "acs_after_layout_default_margin.ket"), "w") as file: -# file.write(rxn.json()) - res = reactionLayoutDiff( indigo, rxn, "acs_after_layout_default_margin.ket", - update=upd, update_format="ket", ) print(" Result: {}".format(res)) @@ -64,17 +47,7 @@ def find_diff(a, b): rxn = indigo.loadReaction("CN.CO>CC.CC>CF.CP") rxn.layout() filename = "acs_issue_2389.ket" -# with open(os.path.join(ref, filename), "w") as file: -# file.write(rxn.json()) -with open(os.path.join(ref, filename), "r") as file: - ket_ref = file.read() -ket = rxn.json() -diff = find_diff(ket_ref, ket) -if not diff: - print(filename + ":SUCCEED") -else: - print(filename + ":FAILED") - print(diff) +compare_diff(ref, filename, rxn.json()) print("\n*** 2458 catalist margins margin ***") @@ -93,13 +66,10 @@ def find_diff(a, b): indigo.setOption("bond-length", "14.4") indigo.setOption("render-label-mode", "terminal-hetero") rxn.layout() -# with open(os.path.join(ref, filename), "w") as file: -# file.write(rxn.json()) res = reactionLayoutDiff( indigo, rxn, filename, - update=upd, update_format="ket", ) print(" Result: {}".format(res)) diff --git a/api/tests/integration/tests/layout/basic.py b/api/tests/integration/tests/layout/basic.py index 2ba0c1c17e..1b24873475 100644 --- a/api/tests/integration/tests/layout/basic.py +++ b/api/tests/integration/tests/layout/basic.py @@ -19,14 +19,12 @@ indigo = Indigo() indigo.setOption("molfile-saving-skip-date", "1") -upd = False - print("*** Reaction layout testing ***") test = indigo.loadReaction( "ClCC1CO1>>CN(CC1CO1)S(=O)(=O)C(F)(F)C(F)(F)C(F)(F)C(F)(F)F" ) test.layout() -res = reactionLayoutDiff(indigo, test, "test1.rxn", update=upd) +res = reactionLayoutDiff(indigo, test, "test1.rxn") test.saveRxnfile(joinPathPy("out/test1.rxn", __file__)) print(" Result: {}".format(res)) @@ -73,7 +71,7 @@ def testLayout(m, subset): joinPathPy("molecules/sgroups/datasgroup.mol", __file__) ) m.layout() -res = moleculeLayoutDiff(indigo, m, "test_sgroup.mol", update=upd) +res = moleculeLayoutDiff(indigo, m, "test_sgroup.mol") print(" Result: {}".format(res)) m.saveMolfile(joinPathPy("out/test_sgroup.mol", __file__)) @@ -81,7 +79,7 @@ def testLayout(m, subset): ref = joinPathPy("molecules/sgroups/reaction_datasgroup.rxn", __file__) test = indigo.loadReactionFromFile(ref) test.layout() -res = reactionLayoutDiff(indigo, test, "test_sgroup.rxn", update=upd) +res = reactionLayoutDiff(indigo, test, "test_sgroup.rxn") print(" Result: {}".format(res)) test.saveRxnfile(joinPathPy("out/test_sgroup.rxn", __file__)) @@ -91,7 +89,7 @@ def testLayout(m, subset): joinPathPy("molecules/mol-ind-468.mol", __file__) ) m.layout() -res = moleculeLayoutDiff(indigo, m, "mol-ind-468.mol", update=upd) +res = moleculeLayoutDiff(indigo, m, "mol-ind-468.mol") print(" Result: {}".format(res)) m.saveMolfile(joinPathPy("out/mol-ind-468.mol", __file__)) @@ -102,7 +100,7 @@ def testLayout(m, subset): ) m.layout() # print(m.molfile()) -res = moleculeLayoutDiff(indigo, m, "mol-indsp-93.mol", update=upd) +res = moleculeLayoutDiff(indigo, m, "mol-indsp-93.mol") print(" Result: {}".format(res)) m.saveMolfile(joinPathPy("out/mol-indsp-93.mol", __file__)) @@ -116,9 +114,9 @@ def testLayout(m, subset): sub = mol.getSubmolecule(atoms) sub.layout() # IND-617 -> bug: exception -res = moleculeLayoutDiff(indigo, mol, "ind-617-test-fixed-1.mol", update=upd) +res = moleculeLayoutDiff(indigo, mol, "ind-617-test-fixed-1.mol") print(" mol Result: {}".format(res)) -res = moleculeLayoutDiff(indigo, mol2, "ind-617-test-fixed-2.mol", update=upd) +res = moleculeLayoutDiff(indigo, mol2, "ind-617-test-fixed-2.mol") print(" mol2 Result: {}".format(res)) mol2.saveMolfile(joinPathPy("out/ind-617-test-fixed-2.mol", __file__)) mol.saveMolfile(joinPathPy("out/ind-617-test-fixed-1.mol", __file__)) diff --git a/api/tests/integration/tests/layout/clean2d.py b/api/tests/integration/tests/layout/clean2d.py index fb8137c198..ed58973e14 100644 --- a/api/tests/integration/tests/layout/clean2d.py +++ b/api/tests/integration/tests/layout/clean2d.py @@ -32,7 +32,11 @@ try: item.clean2d() res = moleculeLayoutDiff( - indigo, item, ref.at(idx).rawData(), ref_is_file=False + indigo, + item, + ref.at(idx).rawData(), + ref_is_file=False, + update=False, ) print(" Item #{}: Result: {}".format(idx, res)) saver.sdfAppend(item.clone()) @@ -42,7 +46,7 @@ print("***** Test cleand2d for SMILES 1 *****") m = indigo.loadMolecule("C1=CC=CC=C1") m.clean2d() -res = moleculeLayoutDiff(indigo, m, "clean2d_test1.mol") +res = moleculeLayoutDiff(indigo, m, "clean2d_test1.mol", update=False) print(" Result: {}".format(res)) m.saveMolfile(joinPathPy("out/clean2d_test1.mol", __file__)) @@ -50,6 +54,6 @@ m = indigo.loadMolecule("C=C=C") sm = m.getSubmolecule([0, 1, 2]) sm.clean2d() -res = moleculeLayoutDiff(indigo, sm, "clean2d_test2.mol") +res = moleculeLayoutDiff(indigo, sm, "clean2d_test2.mol", update=False) print(" Result: {}".format(res)) sm.saveMolfile(joinPathPy("out/clean2d_test2.mol", __file__)) diff --git a/api/tests/integration/tests/layout/layout_orientation.py b/api/tests/integration/tests/layout/layout_orientation.py index 0fb8251c3d..669436ed66 100644 --- a/api/tests/integration/tests/layout/layout_orientation.py +++ b/api/tests/integration/tests/layout/layout_orientation.py @@ -26,7 +26,11 @@ def check_case(name): mol = item.clone() mol.layout() res = moleculeLayoutDiff( - indigo, mol, ref.at(idx).rawData(), ref_is_file=False + indigo, + mol, + ref.at(idx).rawData(), + ref_is_file=False, + update=False, ) print(" Item #{}: Result: {}".format(idx, res)) saver.sdfAppend(mol) diff --git a/api/tests/integration/tests/layout/macrocycles.py b/api/tests/integration/tests/layout/macrocycles.py index 28d00b8368..555bfa7199 100644 --- a/api/tests/integration/tests/layout/macrocycles.py +++ b/api/tests/integration/tests/layout/macrocycles.py @@ -42,7 +42,7 @@ mol = item.clone() mol.layout() res = moleculeLayoutDiff( - indigo, mol, ref.at(idx).rawData(), ref_is_file=False + indigo, mol, ref.at(idx).rawData(), ref_is_file=False, update=False ) print(" Result: {}".format(res)) mol.setProperty("test", "Item #{} ".format(idx)) diff --git a/api/tests/integration/tests/layout/reaction_layout_and_clean2d.py b/api/tests/integration/tests/layout/reaction_layout_and_clean2d.py index 0b79599736..de438d251e 100644 --- a/api/tests/integration/tests/layout/reaction_layout_and_clean2d.py +++ b/api/tests/integration/tests/layout/reaction_layout_and_clean2d.py @@ -21,8 +21,6 @@ indigo.setOption("treat-x-as-pseudoatom", "1") indigo.setOption("smart-layout", "1") -upd = False - saver_layout = indigo.writeFile( joinPathPy("out/reaction_layout.rdf", __file__) ) @@ -51,7 +49,6 @@ rxn, ref_layout.at(idx).rawData(), ref_is_file=False, - update=upd, ) print(" Item #{}: Result of layout: {}".format(idx, res)) saver_layout.rdfAppend(rxn) @@ -71,7 +68,6 @@ rxn, ref_clean2d.at(idx).rawData(), ref_is_file=False, - update=upd, ) print(" Item #{}: Result of clean2d: {}".format(idx, res)) saver_clean.rdfAppend(rxn) diff --git a/api/tests/integration/tests/layout/selection_layout.py b/api/tests/integration/tests/layout/selection_layout.py index daea4a4358..1740462aed 100644 --- a/api/tests/integration/tests/layout/selection_layout.py +++ b/api/tests/integration/tests/layout/selection_layout.py @@ -1,18 +1,13 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -40,17 +35,6 @@ def find_diff(a, b): mol = indigo.loadQueryMoleculeFromFile( os.path.join(root, filename + ".ket") ) - mol.layout() - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(getRefFilepath(filename + ".ket"), "r") as file: - ket_ref = file.read() - ket = mol.json() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) diff --git a/api/tests/integration/tests/layout/selective_layout.py b/api/tests/integration/tests/layout/selective_layout.py index c0465e56cf..c554558bd8 100644 --- a/api/tests/integration/tests/layout/selective_layout.py +++ b/api/tests/integration/tests/layout/selective_layout.py @@ -61,7 +61,11 @@ def create_sd_test_dict(fname): mol = item.clone() mol.getSubmolecule(atom_list).layout() res = moleculeLayoutDiff( - indigo, mol, layout_dict[mol_test], ref_is_file=False + indigo, + mol, + layout_dict[mol_test], + ref_is_file=False, + update=False, ) print(" Result: {}".format(res)) mol.setProperty("test", mol_test) @@ -71,7 +75,11 @@ def create_sd_test_dict(fname): mol = item.clone() mol.getSubmolecule(atom_list).clean2d() res = moleculeLayoutDiff( - indigo, mol, clean2d_dict[mol_test], ref_is_file=False + indigo, + mol, + clean2d_dict[mol_test], + ref_is_file=False, + update=False, ) print(" Result: {}".format(res)) mol.setProperty("test", mol_test) diff --git a/api/tests/integration/tests/layout/seq_cycles_layout.py b/api/tests/integration/tests/layout/seq_cycles_layout.py index 099d1b7791..9d1f7365ea 100644 --- a/api/tests/integration/tests/layout/seq_cycles_layout.py +++ b/api/tests/integration/tests/layout/seq_cycles_layout.py @@ -44,6 +44,7 @@ def compare_positions(ket_a, ket_b, eps=0.05): ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -88,18 +89,8 @@ def compare_positions(ket_a, ket_b, eps=0.05): ) mol.layout() - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(mol.json()) - with open(getRefFilepath(filename + ".ket"), "r") as file: - ket_ref = file.read() - ket = mol.json() - diff = compare_positions(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket, diff_fn=compare_positions) # ====================================================================== @@ -306,11 +297,13 @@ def _is_regular_polygon( print(" " + e) else: final_ket = json.dumps(current_data, indent=2) - # with open(os.path.join(ref_path, "multi_seq_1357.ket"), "w") as file: - # file.write(final_ket) - with open(getRefFilepath("multi_seq_1357.ket"), "r") as file: - ket_ref = file.read() - diff = compare_positions(ket_ref, final_ket) + diff = compare_diff( + ref_path, + "multi_seq_1357.ket", + final_ket, + diff_fn=compare_positions, + stdout=False, + ) if not diff: print("multi.ket:SUCCEED") else: @@ -390,11 +383,13 @@ def _run_multi_cycle_selection_test(label, cycle_groups, ref_filename): print(" " + e) else: final_ket = json.dumps(data, indent=2) - with open(os.path.join(ref_path, ref_filename), "w") as file: - file.write(final_ket) - with open(getRefFilepath(ref_filename), "r") as file: - ket_ref = file.read() - diff = compare_positions(ket_ref, final_ket) + diff = compare_diff( + ref_path, + ref_filename, + final_ket, + diff_fn=compare_positions, + stdout=False, + ) if not diff: print("{}:SUCCEED".format(label)) else: diff --git a/api/tests/integration/tests/layout/simple_cycles.py b/api/tests/integration/tests/layout/simple_cycles.py index a632f2c6ad..389101f093 100644 --- a/api/tests/integration/tests/layout/simple_cycles.py +++ b/api/tests/integration/tests/layout/simple_cycles.py @@ -115,7 +115,7 @@ ): mol.layout() res = moleculeLayoutDiff( - indigo, mol, ref.at(idx).rawData(), ref_is_file=False + indigo, mol, ref.at(idx).rawData(), ref_is_file=False, update=False ) print(" Item #{}: Result: {}".format(idx, res)) saver.sdfAppend(mol) diff --git a/api/tests/integration/tests/layout/smiles_layout.py b/api/tests/integration/tests/layout/smiles_layout.py index 7e1f6b1adf..b684da8d1c 100644 --- a/api/tests/integration/tests/layout/smiles_layout.py +++ b/api/tests/integration/tests/layout/smiles_layout.py @@ -1,17 +1,12 @@ -import difflib -import os +import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * # noqa indigo = Indigo() @@ -30,15 +25,4 @@ def find_diff(a, b): rea = indigo.loadReactionFromFile(os.path.join(root, filename + ".smi")) rea.layout() ket = rea.json() - - # with open(os.path.join(ref_path, filename) + ".ket", "w") as file: - # file.write(ket) - - with open(os.path.join(ref_path, filename) + ".ket", "r") as file: - ket_ref = file.read() - diff = find_diff(ket_ref, ket) - if not diff: - print(filename + ".ket:SUCCEED") - else: - print(filename + ".ket:FAILED") - print(diff) + compare_diff(ref_path, filename + ".ket", ket) diff --git a/api/tests/integration/tests/layout/template_layout.py b/api/tests/integration/tests/layout/template_layout.py index 934244f7fb..8508d450f2 100644 --- a/api/tests/integration/tests/layout/template_layout.py +++ b/api/tests/integration/tests/layout/template_layout.py @@ -35,7 +35,7 @@ mol = item.clone() mol.layout() res = moleculeLayoutDiff( - indigo, mol, ref.at(idx).rawData(), ref_is_file=False + indigo, mol, ref.at(idx).rawData(), ref_is_file=False, update=False ) print(" Item #{}: Result: {}".format(idx, res)) saver.sdfAppend(mol) @@ -57,7 +57,7 @@ mol = item.clone() mol.layout() res = moleculeLayoutDiff( - indigo, mol, item.rawData(), ref_is_file=False + indigo, mol, item.rawData(), ref_is_file=False, update=False ) print(" Item #{}: Result: {}".format(idx, res)) saver.sdfAppend(mol) diff --git a/api/tests/integration/tests/reaction/save_ket_layout_1205.py b/api/tests/integration/tests/reaction/save_ket_layout_1205.py index 1a52b511ac..0b51a8e233 100644 --- a/api/tests/integration/tests/reaction/save_ket_layout_1205.py +++ b/api/tests/integration/tests/reaction/save_ket_layout_1205.py @@ -1,35 +1,23 @@ -import difflib import os import sys - -def find_diff(a, b): - return "\n".join(difflib.unified_diff(a.splitlines(), b.splitlines())) - - sys.path.append( os.path.normpath( os.path.join(os.path.abspath(__file__), "..", "..", "..", "common") ) ) +from common.util import compare_diff from env_indigo import * indigo = Indigo() indigo.setOption("json-saving-pretty", True) indigo.setOption("json-use-native-precision", True) +reactions_path = joinPathPy("reactions/", __file__) +filename = "issue_1205" + r1 = indigo.loadReactionFromFile( - joinPathPy("reactions/issue_1205.rxn", __file__) + os.path.join(reactions_path, filename + ".rxn") ) ket_out = r1.json() - -# with open(joinPathPy("reactions/issue_1205.ket", __file__), "w") as file: -# file.write(ket_out) - -with open(joinPathPy("reactions/issue_1205.ket", __file__), "r") as file: - ket_ref = file.read() -diff = find_diff(ket_ref, ket_out) -if diff: - print("Difference found:\n", diff) -else: - print("Test passed") +compare_diff(reactions_path, filename + ".ket", ket_out) diff --git a/api/tests/integration/tests/todo/macrocycles.py b/api/tests/integration/tests/todo/macrocycles.py index 361ff9f51c..ebd8257dac 100644 --- a/api/tests/integration/tests/todo/macrocycles.py +++ b/api/tests/integration/tests/todo/macrocycles.py @@ -40,7 +40,7 @@ mol = item.clone() mol.layout() res = moleculeLayoutDiff( - indigo, mol, ref.at(idx).rawData(), ref_is_file=False + indigo, mol, ref.at(idx).rawData(), ref_is_file=False, update=False ) print(" Result: {}".format(res)) mol.setProperty("test", "Item #{} ".format(idx))