def test_create_delete_2(self):
"""Verify correct DELETE statement is created
for a single GeneID in the gene table."""
# First, retrieve the current state of the gene table.
results1 = test_db_utils.get_data(self.gene_query)
results1_phageids = set()
results1_geneids = set()
for dict in results1:
results1_phageids.add(dict["PhageID"])
results1_geneids.add(dict["GeneID"])
# Second, execute the DELETE statement.
statement = mysqldb.create_delete("gene", "GeneID", "Trixie_1")
test_db_utils.execute(statement)
# Third, retrieve the current state of the gene table.
results2 = test_db_utils.get_data(self.gene_query)
results2_phageids = set()
results2_geneids = set()
for dict in results2:
results2_phageids.add(dict["PhageID"])
results2_geneids.add(dict["GeneID"])
exp = "DELETE FROM gene WHERE GeneID = 'Trixie_1';"
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(len(results1_phageids), 1)
with self.subTest():
self.assertEqual(len(results1_geneids), 2)
with self.subTest():
self.assertEqual(len(results2_phageids), 1)
with self.subTest():
self.assertEqual(len(results2_geneids), 1)
def test_create_trna_table_insert_1(self):
"""Verify trna table INSERT statement is created correctly when
locus_tag, note, and structure, and use are not empty."""
# Note: even though this function returns a string and doesn't
# actually utilize a MySQL database, this test ensures
# that the returned statement will function properly in MySQL.
trna1 = trna.Trna()
trna1.id = "Trixie_1"
trna1.genome_id = "Trixie"
trna1.name = "1"
trna1.locus_tag = "TAG1"
trna1.start = 5
trna1.stop = 10
trna1.length = 200
trna1.orientation = "F"
trna1.note = "misc"
trna1.amino_acid = "Ala"
trna1.anticodon = "AAA"
trna1.structure = "random"
trna1.use = "aragorn"
statement = mysqldb.create_trna_table_insert(trna1)
test_db_utils.execute(statement)
result = test_db_utils.get_data(TRNA_QUERY2)
results = result[0]
exp = ("""INSERT INTO trna """
"""(GeneID, PhageID, Start, Stop, Length, """
"""Name, Orientation, Note, LocusTag, AminoAcid, Anticodon, """
"""Structure, Source) """
"""VALUES """
"""("Trixie_1", "Trixie", 5, 10, 200, "1", "F", "misc", """
""""TAG1", "Ala", "AAA", "random", "aragorn");""")
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["GeneID"], "Trixie_1")
with self.subTest():
self.assertEqual(results["PhageID"], "Trixie")
with self.subTest():
self.assertEqual(results["Start"], 5)
with self.subTest():
self.assertEqual(results["Stop"], 10)
with self.subTest():
self.assertEqual(results["Length"], 200)
with self.subTest():
self.assertEqual(results["Name"], "1")
with self.subTest():
self.assertEqual(results["Orientation"], "F")
with self.subTest():
self.assertEqual(results["Note"].decode("utf-8"), "misc")
with self.subTest():
self.assertEqual(results["LocusTag"], "TAG1")
with self.subTest():
self.assertEqual(results["Structure"].decode("utf-8"), "random")
with self.subTest():
self.assertEqual(results["AminoAcid"], "Ala")
with self.subTest():
self.assertEqual(results["Anticodon"], "AAA")
with self.subTest():
self.assertEqual(results["Source"], "aragorn")
def test_create_gene_table_insert_2(self):
"""Verify gene table INSERT statement is created correctly when
locus_tag is empty."""
# Note: even though this function returns a string and doesn't
# actually utilize a MySQL database, this test ensures
# that the returned statement will function properly in MySQL.
cds1 = cds.Cds()
cds1.id = "SEA_TRIXIE_123"
cds1.genome_id = "Trixie"
cds1.start = 5
cds1.stop = 10
cds1.parts = 1
cds1.translation_length = 20
cds1.name = "Int"
cds1.type = "CDS"
cds1.translation = Seq("ACKLG", IUPAC.protein)
cds1.orientation = "F"
cds1.description = "integrase"
cds1.locus_tag = ""
statement = mysqldb.create_gene_table_insert(cds1)
test_db_utils.execute(statement)
result = test_db_utils.get_data(self.gene_query)
results = result[0]
exp = ("""INSERT INTO gene """
"""(GeneID, PhageID, Start, Stop, Length, Name, """
"""Translation, Orientation, Notes, LocusTag, Parts) """
"""VALUES """
"""("SEA_TRIXIE_123", "Trixie", 5, 10, 20, "Int", """
""""ACKLG", "F", "integrase", NULL, 1);""")
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["GeneID"], "SEA_TRIXIE_123")
with self.subTest():
self.assertEqual(results["LocusTag"], None)
def test_create_delete_1(self):
"""Verify correct DELETE statement is created
for a PhageID in the phage table."""
# First, retrieve the current state of the phage table.
results1 = test_db_utils.get_data(PHAGE_QUERY2)
results1_phageids = set()
for dict in results1:
results1_phageids.add(dict["PhageID"])
# Second, execute the DELETE statement.
statement = mysqldb.create_delete("phage", "PhageID", "Trixie")
test_db_utils.execute(statement)
# Third, retrieve the current state of the phage table.
results2 = test_db_utils.get_data(PHAGE_QUERY2)
results2_phageids = set()
for dict in results2:
results2_phageids.add(dict["PhageID"])
exp = "DELETE FROM phage WHERE PhageID = 'Trixie';"
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(len(results1_phageids), 1)
with self.subTest():
self.assertEqual(len(results2_phageids), 0)
def test_main_1(self, alchemy_mock, gpd_mock, rud_mock):
"""Verify compare runs successfully with:
MySQL, PhagesDB, and GenBank records saved,
a duplicate MySQL accession (for D29 and Trixie),
an invalid accession (for L5),
a duplicate phage.Name (for Constance and Et2Brutus),
a PhagesDB name unmatched to MySQL (for 'unmatched')."""
alchemy_mock.return_value = self.alchemist
gpd_mock.return_value = self.pdb_json_results
rud_mock.return_value = FASTA_FILE
# Make modifications to cause errors.
stmts = []
stmts.append(create_update("phage", "Accession", L5_ACC + "1", "L5"))
stmts.append(create_update("phage", "Accession", TRIXIE_ACC, "D29"))
stmts.append(create_update("phage", "Name", "Dupe", "Constance"))
stmts.append(create_update("phage", "Name", "Dupe", "Et2Brutus"))
stmts.append(create_update("phage", "PhageID", "Dupe", "Constance"))
stmts.append(
create_update("phage", "PhageID", "Dupe_Draft", "Et2Brutus"))
for stmt in stmts:
test_db_utils.execute(stmt)
run.main(self.unparsed_args)
count = count_files(test_folder)
# input("check")
with self.subTest():
self.assertTrue(count > 0)
with self.subTest():
gpd_mock.assert_called()
with self.subTest():
rud_mock.assert_called()
def test_create_phage_table_insert_1(self):
"""Verify phage table INSERT statement is created correctly."""
# Note: even though this function returns a string and doesn't
# actually utilize a MySQL database, this test ensures
# that the returned statement will function properly in MySQL.
gnm = genome.Genome()
gnm.id = "L5"
gnm.name = "L5_Draft"
gnm.host_genus = "Mycobacterium"
gnm.annotation_status = "final"
gnm.accession = "ABC123"
gnm.seq = Seq("ATCG", IUPAC.ambiguous_dna)
gnm.length = 4
gnm.gc = 0.5001
gnm.date = constants.EMPTY_DATE
gnm.retrieve_record = 1
gnm.annotation_author = 1
gnm.cluster = "Singleton"
gnm.subcluster = "A2"
statement = mysqldb.create_phage_table_insert(gnm)
test_db_utils.execute(statement)
phage_data = test_db_utils.get_data(test_db_utils.phage_table_query)
results = phage_data[0]
exp = ("INSERT INTO phage "
"(PhageID, Accession, Name, HostGenus, Sequence, "
"Length, GC, Status, DateLastModified, RetrieveRecord, "
"AnnotationAuthor, Cluster, Subcluster) "
"VALUES "
"('L5', 'ABC123', 'L5_Draft', 'Mycobacterium', 'ATCG', "
f"4, 0.5001, 'final', '{constants.EMPTY_DATE}', 1, "
"1, NULL, 'A2');")
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["PhageID"], "L5")
with self.subTest():
self.assertEqual(results["Accession"], "ABC123")
with self.subTest():
self.assertEqual(results["Name"], "L5_Draft")
with self.subTest():
self.assertEqual(results["HostGenus"], "Mycobacterium")
with self.subTest():
self.assertEqual(results["Sequence"].decode("utf-8"), "ATCG")
with self.subTest():
self.assertEqual(results["Length"], 4)
with self.subTest():
self.assertEqual(results["GC"], 0.5001)
with self.subTest():
self.assertEqual(results["Status"], "final")
with self.subTest():
self.assertEqual(results["DateLastModified"], constants.EMPTY_DATE)
with self.subTest():
self.assertEqual(results["RetrieveRecord"], 1)
with self.subTest():
self.assertEqual(results["AnnotationAuthor"], 1)
with self.subTest():
self.assertIsNone(results["Cluster"])
with self.subTest():
self.assertEqual(results["Subcluster"], "A2")
def setUp(self):
stmt1 = "UPDATE version SET Version = 1"
test_db_utils.execute(stmt1)
stmt2 = "UPDATE version SET Version = 0"
test_db_utils.execute(stmt2, db=DB2)
self.alchemist = AlchemyHandler(database=DB, username=USER, password=PWD)
self.alchemist.build_engine()
self.engine = self.alchemist.engine
def test_main_11(self, getpass_mock):
"""Verify frozen database is created from database
using quoted filter value."""
getpass_mock.side_effect = [USER, PWD]
stmt = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt)
self.unparsed_args.extend(["-f", "phage.Status != 'draft'"])
run.main(self.unparsed_args)
count2 = test_db_utils.get_data(COUNT_PHAGE, db=DB2)
self.assertEqual(count2[0]["count"], 1)
def test_create_gene_table_insert_1(self):
"""Verify gene table INSERT statement is created correctly when
locus_tag is not empty and description contains a "'"."""
# Note: even though this function returns a string and doesn't
# actually utilize a MySQL database, this test ensures
# that the returned statement will function properly in MySQL.
cds1 = cds.Cds()
cds1.id = "SEA_TRIXIE_123"
cds1.genome_id = "Trixie"
cds1.start = 5
cds1.stop = 10
cds1.parts = 1
cds1.translation_length = 20
cds1.length = 200
cds1.name = "Int"
cds1.type = "CDS"
cds1.translation = Seq("ACKLG", IUPAC.protein)
cds1.orientation = "F"
cds1.description = "5' nucleotide phosphatase"
cds1.locus_tag = "TAG1"
statement = mysqldb.create_gene_table_insert(cds1)
test_db_utils.execute(statement)
result = test_db_utils.get_data(GENE_QUERY2)
results = result[0]
exp = ("""INSERT INTO gene """
"""(GeneID, PhageID, Start, Stop, Length, Name, """
"""Translation, Orientation, Notes, LocusTag, Parts) """
"""VALUES """
"""("SEA_TRIXIE_123", "Trixie", 5, 10, 200, "Int", """
""""ACKLG", "F", "5' nucleotide phosphatase", "TAG1", 1);""")
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["GeneID"], "SEA_TRIXIE_123")
with self.subTest():
self.assertEqual(results["PhageID"], "Trixie")
with self.subTest():
self.assertEqual(results["Start"], 5)
with self.subTest():
self.assertEqual(results["Stop"], 10)
with self.subTest():
self.assertEqual(results["Parts"], 1)
with self.subTest():
self.assertEqual(results["Length"], 200)
with self.subTest():
self.assertEqual(results["Name"], "Int")
with self.subTest():
self.assertEqual(results["Translation"].decode("utf-8"), "ACKLG")
with self.subTest():
self.assertEqual(results["Orientation"], "F")
with self.subTest():
self.assertEqual(results["Notes"].decode("utf-8"),
"5' nucleotide phosphatase")
with self.subTest():
self.assertEqual(results["LocusTag"], "TAG1")
def test_main_3(self, getpass_mock):
"""Verify frozen database is created from database with
only one 'final' genome."""
getpass_mock.side_effect = [USER, PWD]
stmt = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt)
self.unparsed_args.extend(["-f", "phage.Status!=draft"])
print(self.unparsed_args)
run.main(self.unparsed_args)
count2 = test_db_utils.get_data(COUNT_PHAGE, db=DB2)
self.assertEqual(count2[0]["count"], 1)
def test_main_5(self, getpass_mock):
"""Verify frozen database is created from database with
no genomes based on two filters."""
getpass_mock.side_effect = [USER, PWD]
stmt = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt)
filters = "phage.Status != draft AND phage.HostGenus = Gordonia"
self.unparsed_args.extend(["-f", filters])
run.main(self.unparsed_args)
count2 = test_db_utils.get_data(COUNT_PHAGE, db=DB2)
self.assertEqual(count2[0]["count"], 0)
def test_main_2(self, alchemy_mock):
"""Verify one GenBank record is retrieved."""
alchemy_mock.return_value = self.alchemist
stmt = create_update("phage", "Accession", TRIXIE_ACC, "Trixie")
test_db_utils.execute(stmt)
run.main(self.unparsed_args)
count = count_files(results_path)
with self.subTest():
self.assertTrue(results_path.exists())
with self.subTest():
self.assertEqual(count, 1)
def test_main_6(self, getpass_mock):
"""Verify frozen database is created from database with
one genome based on two filters from two tables."""
getpass_mock.side_effect = [USER, PWD]
stmt = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt)
filters = "phage.Status != draft AND gene.Notes = repressor"
self.unparsed_args.extend(["-f", filters])
run.main(self.unparsed_args)
count2 = test_db_utils.get_data(COUNT_PHAGE, db=DB2)
self.assertEqual(count2[0]["count"], 1)
def test_create_update_2(self):
"""Verify correct Cluster statement is created for a singleton."""
statement = mysqldb.create_update("phage", "Cluster", "Singleton",
"PhageID", "Trixie")
test_db_utils.execute(statement)
result = test_db_utils.get_data(self.phage_query)
results = result[0]
exp = "UPDATE phage SET Cluster = NULL WHERE PhageID = 'Trixie';"
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertIsNone(results["Cluster"])
def test_create_update_1(self):
"""Verify correct Cluster statement is created for a non-singleton."""
statement = mysqldb.create_update("phage", "Cluster", "B", "PhageID",
"Trixie")
test_db_utils.execute(statement)
result = test_db_utils.get_data(PHAGE_QUERY2)
results = result[0]
exp = "UPDATE phage SET Cluster = 'B' WHERE PhageID = 'Trixie';"
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["Cluster"], "B")
def test_main_3(self, alchemy_mock):
"""Verify no GenBank record is retrieved based on one filter."""
alchemy_mock.return_value = self.alchemist
stmt = create_update("phage", "Accession", TRIXIE_ACC, "Trixie")
test_db_utils.execute(stmt)
self.unparsed_args.extend(["-f", f"phage.Accession!={TRIXIE_ACC}"])
run.main(self.unparsed_args)
count = count_files(results_path)
with self.subTest():
self.assertTrue(results_path.exists())
with self.subTest():
self.assertEqual(count, 0)
def test_install_db_1(self):
"""Verify new database is installed."""
stmt1 = "UPDATE version SET Version = 0"
test_db_utils.execute(stmt1)
before = test_db_utils.get_data(test_db_utils.version_table_query)
result = mysqldb_basic.install_db(self.engine, test_db_utils.TEST_DB_FILEPATH)
after = test_db_utils.get_data(test_db_utils.version_table_query)
with self.subTest():
self.assertNotEqual(before[0]["Version"], after[0]["Version"])
with self.subTest():
self.assertTrue(after[0]["Version"] > 0)
with self.subTest():
self.assertEqual(result, 0)
def test_create_update_3(self):
"""Verify correct Subcluster statement is created for a
non-empty value."""
statement = mysqldb.create_update("phage", "Subcluster", "A2",
"PhageID", "Trixie")
test_db_utils.execute(statement)
result = test_db_utils.get_data(self.phage_query)
results = result[0]
exp = "UPDATE phage SET Subcluster = 'A2' WHERE PhageID = 'Trixie';"
with self.subTest():
self.assertEqual(statement, exp)
with self.subTest():
self.assertEqual(results["Subcluster"], "A2")
def test_main_4(self, alchemy_mock):
"""Verify one GenBank record is retrieved based on one filter."""
alchemy_mock.return_value = self.alchemist
stmt1 = create_update("phage", "Accession", TRIXIE_ACC, "Trixie")
test_db_utils.execute(stmt1)
stmt2 = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt2)
self.unparsed_args.extend(["-f", "phage.Status!=draft"])
run.main(self.unparsed_args)
count = count_files(results_path)
with self.subTest():
self.assertTrue(results_path.exists())
with self.subTest():
self.assertEqual(count, 1)
def test_main_5(self, getpass_mock):
"""Verify database is installed from file and overwrites
existing database."""
getpass_mock.side_effect = [USER, PWD]
# First install a database with data. Then delete version table.
test_db_utils.create_filled_test_db()
test_db_utils.execute("DROP TABLE version")
unparsed_args = get_unparsed_args(option="file")
run.main(unparsed_args)
# Now query for version data. This verifies that it replaced
# the first database.
version_data = test_db_utils.get_data(
test_db_utils.version_table_query)
self.assertEqual(len(version_data), 1)
def test_main_12(self, getpass_mock):
"""Verify data is changed when there is data in the database
and reset = True."""
getpass_mock.side_effect = [USER, PWD]
stmt = create_update("phage", "Status", "final", "Trixie")
test_db_utils.execute(stmt)
self.unparsed_args.extend(["-f", "phage.Status != draft", "-r"])
run.main(self.unparsed_args)
count = test_db_utils.get_data(COUNT_PHAGE, db=DB2)
version = test_db_utils.get_data(test_db_utils.version_table_query,
db=DB2)
with self.subTest():
self.assertEqual(count[0]["count"], 1)
with self.subTest():
self.assertEqual(version[0]["Version"], 0)
def test_main_2(self, alchemy_mock, gpd_mock):
"""Verify duplicate PhagesDB names are identified."""
# Clear accessions so that GenBank is not queried. No need for that.
stmt = create_update("phage", "Accession", "")
test_db_utils.execute(stmt)
alchemy_mock.return_value = self.alchemist
gpd_mock.return_value = ({}, {"L5"}, {"D29"})
run.main(self.unparsed_args)
count = count_files(test_folder)
# input("check")
with self.subTest():
self.assertTrue(count > 0)
with self.subTest():
gpd_mock.assert_called()
def test_main_4(self, alchemy_mock):
"""Verify final data with very recent date are retrieved
with force_download."""
alchemy_mock.return_value = self.alchemist
stmt = create_update("phage", "DateLastModified", "2200-01-01")
test_db_utils.execute(stmt)
unparsed_args = get_unparsed_args(final=True, force_download=True)
run.main(unparsed_args)
count = count_files(phagesdb_genome_folder)
with self.subTest():
# It's not clear how stable the storage of any particular final
# flat file is on PhagesDB. There is possibility that for any
# genome the associated flat file will be removed. So this is
# one area of testing that could be improved. For now, simply
# verify that 1 or more files have been retrieved.
self.assertTrue(count > 0)
def setUp(self):
test_folder.mkdir()
self.alchemist = AlchemyHandler(database=DB, username=USER, password=PWD)
self.alchemist.build_engine()
# Standardize values in certain fields to define the data
stmt1 = create_update("phage", "Status", "draft")
test_db_utils.execute(stmt1)
stmt2 = create_update("phage", "HostGenus", "Mycobacterium")
test_db_utils.execute(stmt2)
stmt3 = create_update("phage", "Accession", "")
test_db_utils.execute(stmt3)
stmt4 = create_update("gene", "Notes", "repressor")
test_db_utils.execute(stmt4)
stmt5 = "UPDATE version SET Version = 1"
test_db_utils.execute(stmt5)
self.unparsed_args = get_unparsed_args()
def test_install_db_2(self, cc_mock):
"""Verify new database is not installed."""
# Raise an error instead of calling check_call() so that
# the exception block is entered.
cc_mock.side_effect = ValueError("Error raised")
stmt1 = "UPDATE version SET Version = 0"
test_db_utils.execute(stmt1)
before = test_db_utils.get_data(test_db_utils.version_table_query)
result = mysqldb_basic.install_db(self.engine, test_db_utils.TEST_DB_FILEPATH)
after = test_db_utils.get_data(test_db_utils.version_table_query)
with self.subTest():
self.assertEqual(before[0]["Version"], after[0]["Version"])
with self.subTest():
self.assertTrue(after[0]["Version"] == 0)
with self.subTest():
self.assertEqual(result, 1)
def setUp(self):
self.alchemist = AlchemyHandler(database=DB, username=USER, password=PWD)
self.alchemist.build_engine()
test_folder.mkdir()
# Standardize values in certain fields to define the data
stmt1 = create_update("phage", "Status", "unknown")
test_db_utils.execute(stmt1)
stmt2 = create_update("phage", "HostGenus", "unknown")
test_db_utils.execute(stmt2)
stmt3 = create_update("phage", "Accession", "")
test_db_utils.execute(stmt3)
stmt4 = create_update("phage", "DateLastModified", "1900-01-01")
test_db_utils.execute(stmt4)
stmt5 = create_update("phage", "RetrieveRecord", "0")
test_db_utils.execute(stmt5)
def test_drop_create_db_1(self):
"""Verify already-existing database is dropped and created."""
before = test_db_utils.check_if_exists()
before_tables = test_db_utils.execute(TABLES_QUERY.format(DB))
result = mysqldb_basic.drop_create_db(self.engine, DB)
after = test_db_utils.check_if_exists()
after_tables = test_db_utils.execute(TABLES_QUERY.format(DB))
with self.subTest():
self.assertTrue(before)
with self.subTest():
self.assertTrue(after)
with self.subTest():
self.assertEqual(result, 0)
with self.subTest():
self.assertTrue(len(before_tables) > 0)
with self.subTest():
self.assertTrue(len(after_tables) == 0)
def setUp(self):
test_folder.mkdir()
# Standardize values in certain fields to define the data
stmts = []
stmts.append(create_update("phage", "Status", "draft"))
stmts.append(create_update("phage", "Accession", ""))
stmts.append(create_update("phage", "AnnotationAuthor", "0"))
stmts.append(create_update("phage", "Accession", TRIXIE_ACC, "Trixie"))
stmts.append(create_update("phage", "Accession", ALICE_ACC, "Alice"))
stmts.append(create_update("phage", "Accession", L5_ACC, "L5"))
stmts.append(create_update("phage", "Accession", TRIXIE_ACC, "D29"))
stmts.append(create_update("phage", "Status", "final", "Trixie"))
stmts.append(create_update("phage", "Status", "final", "Alice"))
stmts.append(create_update("phage", "Status", "final", "L5"))
stmts.append(create_update("phage", "Status", "final", "D29"))
stmts.append(create_update("phage", "AnnotationAuthor", "1", "Trixie"))
stmts.append(create_update("phage", "AnnotationAuthor", "1", "Alice"))
stmts.append(create_update("phage", "AnnotationAuthor", "1", "L5"))
stmts.append(create_update("phage", "AnnotationAuthor", "1", "D29"))
for stmt in stmts:
test_db_utils.execute(stmt)
self.unparsed_args = get_unparsed_args()
self.alchemist = AlchemyHandler(database=DB,
username=USER,
password=PWD)
self.alchemist.build_engine()
self.pdb_data1 = get_pdb_dict()
self.pdb_data2 = get_pdb_dict()
self.pdb_data3 = get_pdb_dict()
self.pdb_data1["phage_name"] = "Trixie"
self.pdb_data2["phage_name"] = "L5"
self.pdb_data3["phage_name"] = "unmatched"
json_results = [self.pdb_data1, self.pdb_data2, self.pdb_data3]
self.pdb_json_data = get_pdb_json_data()
self.pdb_json_data["results"] = json_results
self.pdb_json_results = json_results
def setUp(self):
# Standardize values in certain fields to define the data
stmt1 = create_update("phage", "Status", "draft")
test_db_utils.execute(stmt1)
stmt2 = create_update("phage", "HostGenus", "Mycobacterium")
test_db_utils.execute(stmt2)
stmt3 = create_update("gene", "Notes", "repressor")
test_db_utils.execute(stmt3)
stmt4 = "UPDATE version SET Version = 1"
test_db_utils.execute(stmt4)
self.unparsed_args = get_unparsed_freeze_args()
def setUp(self):
if not test_db_utils.check_if_exists():
test_db_utils.create_empty_test_db()
else:
if len(test_db_utils.execute(TABLES_QUERY.format(DB))) == 0:
test_db_utils.install_db(test_db_utils.SCHEMA_FILEPATH)
self.alchemist = AlchemyHandler(username=USER, password=PWD)
self.alchemist.build_engine()
self.engine = self.alchemist.engine
