def test_error(monkeypatch, capsys):
monkeypatch.setattr(Db, "LiveShell", mock_systemexit)
test_in_args = deepcopy(in_args)
test_in_args.live_shell = True
assert Db.command_line_ui(test_in_args, Db.DbBuddy(), skip_exit=True) is None
monkeypatch.setattr(Db, "LiveShell", mock_fileexistserror)
monkeypatch.setattr(br.TempFile, "save", lambda *_: True)
monkeypatch.setattr(br, "send_traceback", lambda *_: True)
capsys.readouterr()
assert Db.command_line_ui(test_in_args, Db.DbBuddy(), skip_exit=True) is None
out, err = capsys.readouterr()
assert "can be loaded by launching DatabaseBuddy and using the 'load' command." in err
def test_record_instantiation():
rec = Db.Record("Foo")
assert rec.accession == "Foo"
assert not rec.version
assert not rec.record
assert not rec.summary
assert type(rec.summary) == OrderedDict
assert not rec.size
assert not rec.database
assert not rec.type
assert not rec.search_term
assert str(rec) == "Accession:\tFoo\nDatabase:\tNone\nRecord:\tNone\nType:\tNone\n"
rec = Db.Record("Foo", _size='5746')
assert rec.size == 5746
def test_argparse_init(capsys, monkeypatch, hf):
monkeypatch.setattr(sys, "argv", ['DatabaseBuddy.py', "Casp9"])
temp_in_args, dbbuddy = Db.argparse_init()
assert hf.string2hash(str(dbbuddy)) == "b61a8e0e0a97f33ec1e85c09391ada64"
monkeypatch.setattr(sys, "argv", ['DatabaseBuddy.py', "Casp9,Panx3", "Cx43"])
temp_in_args, dbbuddy = Db.argparse_init()
assert hf.string2hash(str(dbbuddy)) == "c717f3c1636ab03f0c5f5e86d5e909cb"
monkeypatch.setattr(sys, "argv", ['DatabaseBuddy.py', "-f"])
with pytest.raises(SystemExit):
Db.argparse_init()
out, err = capsys.readouterr()
assert "DbBuddy.py: error: unrecognized arguments: -f" in err
def test_record_guess_genbank_prot():
randomly_generated_from_regex = ["TXB10644", "DII59567", "FTJ23865", "SRR43454", "OIJ24077", "HNP42487", "TJS12387"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_prot"
assert rec.type == "protein"
def test_record_guess_genbank_nuc():
randomly_generated_from_regex = ["PU844519", "I96398", "V72255", "M06308", "KP485089", "T79891", "R36898"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_nuc"
assert rec.type == "nucleotide"
def test_record_guess_genbank_pdb():
randomly_generated_from_regex = ["2OOX", "4M7U", "700Y", "6TNH_2", "5CTC_C", "52O0", "3QNM"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_prot"
assert rec.type == "protein"
def test_instantiate_dbbuddy_from_handle():
tmp_file = br.TempFile()
tmp_file.write(", ".join(ACCNS))
tmp_file.open("r")
dbbuddy = Db.DbBuddy(tmp_file.handle)
for accn in ACCNS:
assert accn in dbbuddy.records
def test_print_simple(capsys):
dbbuddy = Db.DbBuddy(", ".join(ACCNS[:4]))
dbbuddy.print()
out, err = capsys.readouterr()
out = re.sub(" +\n", "\n", out)
assert out == '''[m[40m[97m[96mACCN [92mDB [91mType [93mrecord
[96mNP_001287575.1 [92mncbi_prot [91mprot [93msummary
[96mADH10263.1 [92mncbi_prot [91mprot [93msummary
[96mXP_005165403.2 [92mncbi_prot [91mprot [93msummary
[96mA0A087WX72 [92muniprot [91mprot [93msummary
[m'''
dbbuddy.print(-2)
out, err = capsys.readouterr()
out = re.sub(" +\n", "\n", out)
assert out == '''[m[40m[97m[96mACCN [92mDB [91mType [93mrecord
[96mXP_005165403.2 [92mncbi_prot [91mprot [93msummary
[96mA0A087WX72 [92muniprot [91mprot [93msummary
[m'''
dbbuddy.out_format = "ids"
dbbuddy.print()
out, err = capsys.readouterr()
out = re.sub(" +\n", "\n", out)
assert out == '''[m[40m[97m[96mNP_001287575.1
[96mADH10263.1
[96mXP_005165403.2
[96mA0A087WX72
[m'''
dbbuddy.out_format = "accessions"
dbbuddy.print()
out, err = capsys.readouterr()
out = re.sub(" +\n", "\n", out)
assert out == '''[m[40m[97m[96mNP_001287575.1
def test_terminal_colors():
term_colors = Db.terminal_colors()
for color in [
Db.CYAN, Db.GREEN, Db.RED, Db.YELLOW, Db.GREY, Db.MAGENTA, Db.CYAN,
Db.GREEN
]:
assert next(term_colors) == color
def test_print_trash(capsys):
dbbuddy = Db.DbBuddy(", ".join(ACCNS[:4]))
dbbuddy.filter_records("00", "remove")
dbbuddy.print(group="trash_bin")
out, err = capsys.readouterr()
out = re.sub(" +\n", "\n", out)
assert out == '''[m[40m[97m[96mACCN [92mDB [91mType [93mrecord
def test_server(monkeypatch):
dbbuddy = Db.DbBuddy(", ".join(ACCNS))
assert type(dbbuddy.server("uniprot")) == Db.UniProtRestClient
assert type(dbbuddy.server_clients["uniprot"]) == Db.UniProtRestClient
assert type(dbbuddy.server("ncbi")) == Db.NCBIClient
assert type(dbbuddy.server_clients["ncbi"]) == Db.NCBIClient
def patch_ensembl_rest_action(*args, **kwargs):
print("patch_ensembl_rest_action\nargs: %s\nkwargs: %s" %
(args, kwargs))
return {
'species': [{
'display_name': 'Saccharomyces cerevisiae'
}, {
'display_name': 'C.savignyi'
}, {
'display_name': 'Microbat'
}]
}
monkeypatch.setattr(Db.EnsemblRestClient, "perform_rest_action",
patch_ensembl_rest_action) # No internet needed
assert type(dbbuddy.server("ensembl")) == Db.EnsemblRestClient
assert type(dbbuddy.server_clients["ensembl"]) == Db.EnsemblRestClient
assert type(
dbbuddy.server("ensembl")
) == Db.EnsemblRestClient # Repeat to grab previously stored client
with pytest.raises(ValueError) as err:
dbbuddy.server("foo")
assert '"uniprot", "ncbi", and "ensembl" are the only valid options, not foo' in str(
err)
def test_liveshell_do_failures(monkeypatch, capsys):
monkeypatch.setattr(Db.LiveShell, "cmdloop", mock_cmdloop)
monkeypatch.setattr(Db.LiveShell, "dump_session", lambda _: True)
dbbuddy = Db.DbBuddy()
crash_file = br.TempFile(byte_mode=True)
liveshell = Db.LiveShell(dbbuddy, crash_file)
liveshell.do_failures("Blahh")
out, err = capsys.readouterr()
assert "No failures to report\n\n" in out
dbbuddy.failures["Foo"] = Db.Failure("Bar", "Fake failure")
liveshell.do_failures()
out, err = capsys.readouterr()
assert "The following failures have occured\n" in out
assert "Bar\nFake failure" in out
def test_liveshell_dump_session(monkeypatch):
monkeypatch.setattr(Db.LiveShell, "cmdloop", mock_cmdloop)
dbbuddy = Db.DbBuddy(_databases="uniprot")
dbbuddy.server_clients["uniprot"] = Db.UniProtRestClient(dbbuddy)
crash_file = br.TempFile(byte_mode=True)
liveshell = Db.LiveShell(dbbuddy, crash_file)
pre_dump = liveshell.crash_file.read()
liveshell.dump_session()
assert pre_dump == liveshell.crash_file.read()
liveshell.dbbuddy.search_terms.append("Blahh")
liveshell.dump_session()
assert pre_dump != liveshell.crash_file.read()
assert liveshell.dbbuddy.server_clients['uniprot'].lock
assert not liveshell.dbbuddy.server_clients['ensembl']
assert liveshell.undo
def test_record_guess_uniprot():
randomly_generated_from_regex = ["K2O417", "I0DZU1", "A8GFV0", "J3K7W6", "O3U582", "C3YWY7GUS7", "Q0L5K7",
"Q5FO16", "K9WMR5XBZ1"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "uniprot"
assert rec.type == "protein"
def test_main(monkeypatch):
monkeypatch.setattr(sys, "argv", ["DatabaseBuddy", "Casp9,Panx3", "-ls"])
monkeypatch.setattr(Db, "command_line_ui", lambda *_: True)
assert Db.main()
monkeypatch.setattr(Db, "command_line_ui", mock_keyboardinterrupt)
assert not Db.main()
monkeypatch.setattr(Db, "command_line_ui", mock_guesserror)
assert not Db.main()
monkeypatch.setattr(Db, "command_line_ui", mock_systemexit)
assert not Db.main()
monkeypatch.setattr(Db, "command_line_ui", mock_fileexistserror)
monkeypatch.setattr(br, "send_traceback", lambda *_: True)
assert not Db.main()
def test_record_guess_genbank_mga():
randomly_generated_from_regex = ["BJCKQ0111866", "YXRUT6401652", "PVAGD7038775", "OGSVS5937667",
"LPMXX1503516", "NTEWQ3440974", "CTDME6774392"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_prot"
assert rec.type == "protein"
def test_record_guess_genbank_genome():
randomly_generated_from_regex = ["LJIJ8045260586", "MRMV14919426", "WBGU8744627061", "WYNM11788712",
"SQVS3339736221", "LVGB461502017", "FAWG101678469"]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_nuc"
assert rec.type == "nucleotide"
def test_liveshell_do_quit(monkeypatch, capsys):
monkeypatch.setattr(Db.LiveShell, "cmdloop", mock_cmdloop)
monkeypatch.setattr(Db.LiveShell, "dump_session", lambda _: True)
dbbuddy = Db.DbBuddy()
crash_file = br.TempFile(byte_mode=True)
liveshell = Db.LiveShell(dbbuddy, crash_file)
dbbuddy.records["Foo"] = "Bar"
monkeypatch.setattr(br, "ask", lambda _, **kwargs: False)
liveshell.do_quit(None)
out, err = capsys.readouterr()
assert "Aborted...\n\n" in out
with pytest.raises(SystemExit):
monkeypatch.setattr(br, "ask", lambda _, **kwargs: True)
liveshell.do_quit(None)
out, err = capsys.readouterr()
assert "Goodbye" in out
def test_uniprotrestclient_count_hits(monkeypatch):
dbbuddy = Db.DbBuddy("inx15,inx16")
client = Db.UniProtRestClient(dbbuddy)
monkeypatch.setattr(Db, 'urlopen', mock_urlopen_uniprot_count_hits)
assert client.count_hits() == 10
for indx in range(10):
client.dbbuddy.search_terms.append("a" * 110)
assert client.count_hits() == 20
monkeypatch.setattr(Db, 'urlopen', mock_raise_httperror)
assert client.count_hits() == 0
assert "d3b8e6bb4b9094117b7555b01dc85f64" in client.dbbuddy.failures
with pytest.raises(ValueError) as err:
client.dbbuddy.search_terms[0] = "a" * 1001
client.count_hits()
assert "Search term exceeds size limit of 1000 characters." in str(err)
def test_uniprotrestclient_query_uniprot(capsys, monkeypatch):
dbbuddy = Db.DbBuddy()
client = Db.UniProtRestClient(dbbuddy)
monkeypatch.setattr(Db, 'urlopen', mock_urlopen_handle_uniprot_ids)
client.query_uniprot("inx15", {"format": "list"})
assert client.results_file.read() == '''# Search: inx15
A8XEF9
O61786
A0A0H5SBJ0
//
'''
# Also make sure request_params can come in as a list
monkeypatch.setattr(Db, 'urlopen', mock_urlopen_handle_uniprot_ids)
client.query_uniprot("inx15", [{"format": "list"}])
# Errors
monkeypatch.setattr(Db, 'urlopen', mock_raise_httperror)
client.query_uniprot("inx15", [{"format": "list"}])
assert client.http_errors_file.read() == "Uniprot search failed for 'inx15'\nHTTP Error 101: " \
"Fake HTTPError from Mock\n//\n"
monkeypatch.setattr(Db, 'urlopen', mock_raise_urlerror_8)
client.query_uniprot("inx15", [{"format": "list"}])
assert "Uniprot request failed, are you connected to the internet?" in client.http_errors_file.read(
)
monkeypatch.setattr(Db, 'urlopen', mock_raise_urlerror)
client.query_uniprot("inx15", [{"format": "list"}])
assert "<urlopen error Fake URLError from Mock>" in client.http_errors_file.read(
)
monkeypatch.setattr(Db, 'urlopen', mock_raise_keyboardinterrupt)
client.query_uniprot("inx15", [{"format": "list"}])
out, err = capsys.readouterr()
assert "\n\tUniProt query interrupted by user\n" in err
params = {
"format":
"tab",
"columns":
"id,entry name,length,organism-id,organism,protein names,comments"
}
client.query_uniprot("ABXEF9", params)
def test_liveshell_do_save(monkeypatch, capsys):
monkeypatch.setattr(Db.LiveShell, "cmdloop", mock_cmdloop)
dbbuddy = Db.DbBuddy()
crash_file = br.TempFile(byte_mode=True)
liveshell = Db.LiveShell(dbbuddy, crash_file)
dbbuddy.records["foo"] = "bar"
# Standard, no problems
tmp_dir = br.TempDir()
monkeypatch.setattr("builtins.input",
lambda _: "%s/save_dir/save_file1" % tmp_dir.path)
liveshell.do_save(None)
out, err = capsys.readouterr()
assert "Live session saved\n\n" in out
assert os.path.isfile("%s/save_dir/save_file1.db" % tmp_dir.path)
with open("%s/save_dir/save_file1.db" % tmp_dir.path, "rb") as ifile:
assert len(ifile.read()) in [
279, 281
] # Different versions of python give different file sizes
# File exists, abort
monkeypatch.setattr(br, "ask", lambda _, **kwargs: False)
liveshell.do_save("%s/save_dir/save_file1" % tmp_dir.path)
out, err = capsys.readouterr()
assert "Abort...\n\n" in out
# PermissionError
monkeypatch.setattr("builtins.open", OpenPermissionError)
liveshell.do_save("%s/save_dir/save_file2" % tmp_dir.path)
out, err = capsys.readouterr()
assert "Error: You do not have write privileges to create a file in the specified directory.\n\n" in out
assert not os.path.isfile("%s/save_dir/save_file2.db" % tmp_dir.path)
def makedirs_permissionerror(*args, **kwargs):
print("makedirs_permissionerror\nargs: %s\nkwargs: %s" %
(args, kwargs))
raise PermissionError
monkeypatch.setattr(os, "makedirs", makedirs_permissionerror)
liveshell.do_save("%s/save_dir/deeper_dir/save_file2" % tmp_dir.path)
out, err = capsys.readouterr()
assert "Error: You do not have write privileges to create a directory in the specified path.\n\n" in out
assert not os.path.isfile(
"%s/save_dir/deeper_dir/save_file2.db" % tmp_dir.path)
def test_search_ensembl(monkeypatch, capsys, hf):
def patch_ensembl_perform_rest_action(*args, **kwargs):
print("patch_ensembl_perform_rest_action\nargs: %s\nkwargs: %s" %
(args, kwargs))
with open("%s/ensembl_species.json" % test_files, "r") as ifile:
return json.load(ifile)
def patch_search_ensembl_empty(*args, **kwargs):
print("patch_search_ensembl_empty\nargs: %s\nkwargs: %s" %
(args, kwargs))
return
def patch_search_ensembl_results(*args, **kwargs):
print("patch_search_ensembl_empty\nargs: %s\nkwargs: %s" %
(args, kwargs))
with open("%s/ensembl_search_results.txt" % test_files, "r") as ifile:
client.results_file.write(ifile.read())
return
test_files = "%s/mock_resources/test_databasebuddy_clients/" % hf.resource_path
monkeypatch.setattr(Db.EnsemblRestClient, "perform_rest_action",
patch_ensembl_perform_rest_action)
# monkeypatch.setattr(br, "run_multicore_function", patch_search_ensembl_empty)
monkeypatch.setattr(Db.EnsemblRestClient, "_mc_search",
patch_search_ensembl_empty)
dbbuddy = Db.DbBuddy(", ".join(ACCNS[7:]))
client = Db.EnsemblRestClient(dbbuddy)
client.dbbuddy.search_terms = ["Panx3"]
client.dbbuddy.records["ENSLAFG00000006034"] = Db.Record(
"ENSLAFG00000006034")
client.search_ensembl()
out, err = capsys.readouterr()
assert err == "Searching Ensembl for Panx3...\nEnsembl returned no results\n"
assert not client.dbbuddy.records["ENSLAFG00000006034"].record
# monkeypatch.setattr(br, "run_multicore_function", patch_search_ensembl_results)
monkeypatch.setattr(Db.EnsemblRestClient, "_mc_search",
patch_search_ensembl_results)
client.search_ensembl()
assert hf.string2hash(str(
client.dbbuddy)) == "95dc1ecce077bef84cdf2d85ce154eef"
assert len(client.dbbuddy.records) == 44, print(str(client.dbbuddy))
assert client.dbbuddy.records["ENSLAFG00000006034"].database == "ensembl"
def test_record_guess_ensembl():
accns = ["ENSRNOG00000018630", "ENSMUSG00000057666", "ENSPTRG00000004577",
"ENSCAFG00000015077", "ENSPPYG00000004189", "ENSPCAG00000006928",
"ENSOPRG00000012514", "ENSECAG00000022051", "ENSTSYG00000002171",
"FBgn0001987", "FBtr0330306", "FBcl0254909"]
for accn in accns:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ensembl"
assert rec.type == "nucleotide"
def test_record_update():
rec = Db.Record("K9WMR5XBZ1")
summary = OrderedDict([("ACCN", "F6SBJ1"), ("DB", "uniprot"), ("entry_name", "F6SBJ1_HORSE"), ("length", "451"),
("organism-id", "9796"), ("organism", "Equus caballus (Horse)"),
("protein_names", "Caspase"), ("comments", "Caution (1); Sequence similarities (1)"),
("record", "summary")])
new_rec = Db.Record("F6SBJ1", _version=None, _record=None, summary=summary, _size=451,
_database="uniprot", _type="protein", _search_term="casp9")
rec.update(new_rec)
assert rec.accession == "F6SBJ1"
assert not rec.version
assert not rec.record
assert list(rec.summary) == ["ACCN", "DB", "entry_name", "length", "organism-id",
"organism", "protein_names", "comments", "record"]
assert rec.size == 451
assert rec.database == "uniprot"
assert rec.type == "protein"
assert rec.search_term == "casp9"
assert str(rec) == "Accession:\tF6SBJ1\nDatabase:\tuniprot\nRecord:\tNone\nType:\tprotein\n"
def test_exit(monkeypatch, capsys):
class MockExitUsage(object):
@staticmethod
def increment(*args):
print(args)
return True
@staticmethod
def save():
return True
monkeypatch.setattr(br, "Usage", MockExitUsage)
monkeypatch.setattr(Db, "LiveShell", lambda *_: True)
test_in_args = deepcopy(in_args)
with pytest.raises(SystemExit):
Db.command_line_ui(test_in_args, Db.DbBuddy())
out, err = capsys.readouterr()
assert "('DatabaseBuddy', '%s', 'LiveShell', 0)" % Db.VERSION.short() in out
def test_liveshell_do_format(monkeypatch, capsys):
monkeypatch.setattr(Db.LiveShell, "cmdloop", mock_cmdloop)
monkeypatch.setattr(Db.LiveShell, "dump_session", lambda _: True)
dbbuddy = Db.DbBuddy()
crash_file = br.TempFile(byte_mode=True)
liveshell = Db.LiveShell(dbbuddy, crash_file)
monkeypatch.setattr("builtins.input", lambda _: "Foo")
liveshell.do_format(None)
out, err = capsys.readouterr()
assert "'Foo'" in out
assert "is not a valid format" in out
assert dbbuddy.out_format == "summary"
for frmt in Db.FORMATS:
liveshell.do_format(frmt)
out, err = capsys.readouterr()
assert "Output format changed to" in out
assert frmt in out
assert dbbuddy.out_format == frmt
def test_retrieve_sequences(monkeypatch, capsys, sb_resources, hf):
# Don't actually run anything, retrieve_summary() is tested elsewhere
monkeypatch.setattr(Db, "retrieve_summary", lambda *_: True)
monkeypatch.setattr(Db, "retrieve_sequences", lambda *_: True)
test_in_args = deepcopy(in_args)
test_in_args.retrieve_sequences = True
dbbuddy = Db.DbBuddy()
dbbuddy.failures = OrderedDict([("Foo", ValueError("Blahh")), ("Bar", AttributeError("Blahh"))])
dbbuddy.records = sb_resources.get_one("f d").records
for rec in dbbuddy.records:
rec.id = re.sub("α", "", rec.id)
rec.description = re.sub("α", "", rec.description)
dbbuddy.records = OrderedDict([(rec.id, rec) for rec in dbbuddy.records])
for accn, rec in dbbuddy.records.items():
rec.size = len(rec)
rec.record = rec
with pytest.raises(SystemExit):
Db.command_line_ui(test_in_args, dbbuddy)
out, err = capsys.readouterr()
assert dbbuddy.out_format == "fasta"
assert hf.string2hash(out) == "5438dd48c22fd7b6cf2d3da637d333b6"
assert err == """\
# ###################### Failures ###################### #
Foo
Blahh
Bar
Blahh
# ############################################## #
"""
monkeypatch.setattr(br, "ask", lambda _, **kwargs: False)
for accn, rec in dbbuddy.records.items():
rec.size *= 100
with pytest.raises(SystemExit):
Db.command_line_ui(test_in_args, dbbuddy)
out, err = capsys.readouterr()
assert out == '\x1b[91mAborted...\n\n\x1b[m\x1b[40m'
def test_record_breakdown():
dbbuddy = Db.DbBuddy(", ".join(ACCNS))
for accn, rec in dbbuddy.records.items():
if accn in ACCNS[:3]:
rec.record = True
elif accn in ACCNS[3:6]:
rec.summary = True
breakdown = dbbuddy.record_breakdown()
assert breakdown["accession"] == ["XM_003978475", "ENSAMEG00000011912", "ENSCJAG00000008732", "ENSMEUG00000000523"]
assert breakdown["summary"] == ["A0A087WX72", "A0A096MTH0", "A0A0A9YFB0"]
assert breakdown["full"] == ["NP_001287575.1", "ADH10263.1", "XP_005165403.2"]
def test_record_guess_genbank_gi():
randomly_generated_from_regex = [
"13545654", "1445", "9876513546531", "154351", "135464316", "4684315",
"21240"
]
for accn in randomly_generated_from_regex:
rec = Db.Record(accn)
rec.guess_database()
assert rec.database == "ncbi_nuc"
assert rec.type == "gi_num"
assert str(rec.gi) == accn
assert rec.accession == accn
def test_instantiate_empty_dbbuddy_obj():
dbbuddy = Db.DbBuddy()
assert dbbuddy.search_terms == []
assert type(dbbuddy.records) == OrderedDict
assert not dbbuddy.records
assert type(dbbuddy.trash_bin) == OrderedDict
assert dbbuddy.out_format == "summary"
assert type(dbbuddy.failures) == OrderedDict
assert dbbuddy.databases == ["ncbi_nuc", "ncbi_prot", "uniprot", "ensembl"]
for client in ['ncbi', 'ensembl', 'uniprot']:
assert dbbuddy.server_clients[client] is False
assert dbbuddy.memory_footprint == 0
